Audio Forense:
El Trío de Poder

# Instalar todas las dependencias del laboratorio
pip3 install librosa mutagen numpy scipy matplotlib \
             pyAudioAnalysis torch torchaudio \
             pyannote.audio soundfile

# Verificar librosa (la más importante)
python3 -c "import librosa; print('librosa', librosa.__version__)"

#!/usr/bin/env python3
# archivo: ~/lab-forense/analisis_masivo.py
# Detecta anomalías de bitrate en un directorio de evidencias

import mutagen
import os, json
from pathlib import Path

# Bitrate esperado para todos los archivos (en bps)
BITRATE_ESPERADO = 320000
DIRECTORIO = "/root/lab-forense/evidencia"

anomalias = []
procesados = 0

def flag_evidence(filepath, bitrate_real):
    """Registra el archivo como sospechoso."""
    anomalias.append({
        "archivo": filepath,
        "bitrate_real": bitrate_real,
        "bitrate_esperado": BITRATE_ESPERADO,
        "diferencia": abs(bitrate_real - BITRATE_ESPERADO)
    })

dataset = list(Path(DIRECTORIO).rglob("*.mp3")) + \
          list(Path(DIRECTORIO).rglob("*.wav")) + \
          list(Path(DIRECTORIO).rglob("*.flac"))

for file in dataset:
    try:
        audio = mutagen.File(file)
        if audio is None:
            continue
        bitrate = getattr(audio.info, 'bitrate', 0) * 1000
        if bitrate != BITRATE_ESPERADO:
            flag_evidence(str(file), bitrate)
        procesados += 1
    except Exception as e:
        print(f"[ERROR] {file}: {e}")

# Mostrar resultados
print(f"\n{'='*50}")
print(f"Archivos procesados: {procesados}")
print(f"Anomalías detectadas: {len(anomalias)}")
print(f"\n[ANOMALÍAS]")
for a in anomalias:
    print(f"  ⚑ {a['archivo']}")
    print(f"    Esperado: {a['bitrate_esperado']}bps | Real: {a['bitrate_real']}bps")

# Guardar reporte JSON
with open("/root/lab-forense/reportes/anomalias.json", "w") as f:
    json.dump(anomalias, f, indent=2)

#!/usr/bin/env python3
# registro_custodia.py — crea el acta de cadena de custodia

import hashlib, json, datetime
from pathlib import Path

def hash_archivo(filepath):
    sha256 = hashlib.sha256()
    with open(filepath, 'rb') as f:
        while chunk := f.read(8192):
            sha256.update(chunk)
    return sha256.hexdigest()

directorio = Path("/root/lab-forense/evidencia")
registro = {
    "caso": "CASO-2026-001",
    "perito": "[Tu nombre]",
    "fecha_incautacion": datetime.datetime.now().isoformat(),
    "evidencias": []
}

for archivo in directorio.glob("*.*"):
    entry = {
        "nombre": archivo.name,
        "tamaño_bytes": archivo.stat().st_size,
        "sha256": hash_archivo(archivo),
        "timestamp": datetime.datetime.now().isoformat()
    }
    registro["evidencias"].append(entry)
    print(f"✓ {archivo.name}: {entry['sha256'][:16]}...")

with open("/root/lab-forense/reportes/cadena_custodia.json", "w") as f:
    json.dump(registro, f, indent=2, ensure_ascii=False)
print("\n✅ Registro de cadena de custodia guardado.")

import librosa
import soundfile as sf
import numpy as np

# Cargar el archivo de evidencia
data, sr = librosa.load('~/lab-forense/procesado/evidencia_01_std.wav',
                        sr=None)

# Separar componentes harmónicas (voz) y percusivas (ruido/impactos)
armonica, percusiva = librosa.effects.hpss(data)

# Guardar las componentes separadas
sf.write('~/lab-forense/procesado/voz_separada.wav', armonica, sr)
sf.write('~/lab-forense/procesado/ruido_separado.wav', percusiva, sr)

print(f"✓ Separación completada. Sample rate: {sr} Hz")
print(f"  Duración: {len(data)/sr:.2f} segundos")

#!/usr/bin/env python3
# detector_empalmes.py

import librosa
import librosa.display
import numpy as np
import matplotlib.pyplot as plt
import json

# Cargar evidencia
y, sr = librosa.load('~/lab-forense/procesado/evidencia_01_std.wav')

# Calcular espectrograma de amplitud
D = librosa.amplitude_to_db(
    np.abs(librosa.stft(y)), ref=np.max
)

# Detectar cambios bruscos de energía (posibles cortes)
energia = np.sum(D**2, axis=0)
umbral = np.mean(energia) + 2.5 * np.std(energia)
frames_anomalos = np.where(np.abs(np.diff(energia)) > umbral)[0]

# Convertir frames a segundos
tiempos_anomalos = librosa.frames_to_time(frames_anomalos, sr=sr)

# Generar visualización
fig, axes = plt.subplots(2, 1, figsize=(14, 8))

# Forma de onda
librosa.display.waveshow(y, sr=sr, ax=axes[0], color='#00ff88')
axes[0].set_title('Forma de Onda', color='white')
axes[0].set_facecolor('#0a1018')
for t in tiempos_anomalos:
    axes[0].axvline(x=t, color='red', linewidth=1.5, alpha=0.8)

# Espectrograma
librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='hz',
                         ax=axes[1], cmap='magma')
axes[1].set_title('Espectrograma', color='white')
for t in tiempos_anomalos:
    axes[1].axvline(x=t, color='red', linewidth=1.5, alpha=0.8)

plt.tight_layout()
plt.savefig('~/lab-forense/reportes/analisis_espectral.png',
            dpi=150, facecolor='#060a0f')
plt.show()

# Informe de anomalías
informe = {
    "total_anomalias": len(tiempos_anomalos),
    "puntos_sospechosos": [round(float(t), 3) for t in tiempos_anomalos]
}
print(json.dumps(informe, indent=2))
with open('~/lab-forense/reportes/empalmes.json', 'w') as f:
    json.dump(informe, f, indent=2)

#!/usr/bin/env python3
# detector_deepfake.py — análisis de métricas para detección de voz sintética

import librosa
import numpy as np

def analizar_autenticidad(ruta_audio):
    y, sr = librosa.load(ruta_audio, sr=None)
    resultados = {}

    # 1. Entropía espectral — valores altos indican voz sintética
    espectro = np.abs(librosa.stft(y))
    espectro_norm = espectro / (np.sum(espectro, axis=0, keepdims=True) + 1e-10)
    entropia = -np.sum(espectro_norm * np.log2(espectro_norm + 1e-10), axis=0)
    resultados["entropia_media"] = float(np.mean(entropia))

    # 2. Estabilidad del tono fundamental (F0)
    f0, voiced_flag, _ = librosa.pyin(y, fmin=50, fmax=400)
    f0_valido = f0[~np.isnan(f0)]
    if len(f0_valido) > 0:
        variacion = np.std(f0_valido) / (np.mean(f0_valido) + 1e-10)
        resultados["estabilidad_f0"] = 1 - min(variacion, 1.0)
    else:
        resultados["estabilidad_f0"] = 0.0

    # 3. Zero Crossing Rate — micro-irregularidades
    zcr = librosa.feature.zero_crossing_rate(y)[0]
    resultados["variabilidad_zcr"] = float(np.std(zcr))

    # 4. Diagnóstico
    e = resultados["entropia_media"]
    f = resultados["estabilidad_f0"]

    if e > 0.90 and f > 0.95:
        diagnostico = "⚠️  POSIBLE DEEPFAKE — métricas fuera de rango natural"
    elif e > 0.85 or f > 0.92:
        diagnostico = "🔍 SOSPECHOSO — requiere análisis adicional"
    else:
        diagnostico = "✅ DENTRO DE PARÁMETROS NORMALES de voz humana"

    resultados["diagnostico"] = diagnostico
    return resultados

# Ejecutar análisis
r = analizar_autenticidad("~/lab-forense/procesado/evidencia_01_std.wav")
print("═══ INFORME DE AUTENTICIDAD ═══")
for k, v in r.items():
    print(f"  {k}: {v:.4f}" if isinstance(v, float) else f"  {k}: {v}")

#!/usr/bin/env python3
# steg_analyzer.py — análisis de esteganografía en WAV

import wave, numpy as np, sys

def analizar_lsb(ruta_wav):
    with wave.open(ruta_wav, 'rb') as wf:
        frames = wf.readframes(wf.getnframes())
        muestras = np.frombuffer(frames, dtype=np.int16)

    # Extraer bits menos significativos
    lsb = muestras & 1

    # Estadística — si hay datos ocultos, la distribución LSB es no aleatoria
    proporcion_unos = np.mean(lsb)
    entropia_lsb = -(2 * proporcion_unos * np.log2(proporcion_unos + 1e-10))

    print(f"Muestras analizadas: {len(muestras):,}")
    print(f"Proporción LSB=1:    {proporcion_unos:.4f} (esperado ~0.5)")
    print(f"Entropía LSB:        {entropia_lsb:.4f} (max=1.0)")

    if abs(proporcion_unos - 0.5) > 0.05:
        print("\n⚠️  POSIBLE DATOS OCULTOS — distribución LSB anómala")
    else:
        print("\n✅ Distribución LSB normal — no se detectan datos ocultos obvios")

    # Intentar extraer datos ocultos
    print("\n[Primeros 64 bytes de los LSB como texto]:")
    bits = lsb[:512]
    chars = []
    for i in range(0, len(bits), 8):
        byte = 0
        for j, bit in enumerate(bits[i:i+8]):
            byte |= (int(bit) << (7-j))
        if 32 <= byte <= 126:
            chars.append(chr(byte))
        else:
            chars.append('.')
    print(''.join(chars))

analizar_lsb("~/lab-forense/evidencia/evidencia_01.wav")

import librosa, numpy as np, matplotlib.pyplot as plt

y, sr = librosa.load("~/lab-forense/evidencia/evidencia_01.wav", sr=None)
D = np.abs(librosa.stft(y))

# Energía en banda ultrasónica (>15kHz) — zona sospechosa para datos ocultos
freqs = librosa.fft_frequencies(sr=sr)
mask_ultra = freqs > 15000
energia_ultra = np.mean(D[mask_ultra, :])
energia_total = np.mean(D)
ratio = energia_ultra / (energia_total + 1e-10)

print(f"Energía en banda >15kHz: {energia_ultra:.6f}")
print(f"Ratio respecto al total: {ratio:.4f}")
if ratio > 0.01:
    print("⚠️  ACTIVIDAD ULTRASÓNICA SOSPECHOSA detectada")
else:
    print("✅ Sin actividad ultrasónica anómala")

#!/usr/bin/env python3
# diarizacion.py — identificar hablantes en el audio
# Requiere: pip install pyannote.audio
# Y un token de HuggingFace: https://huggingface.co/settings/tokens

from pyannote.audio import Pipeline
import json

# Cargar el pipeline preentrenado
pipeline = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-3.1",
    use_auth_token="TU_TOKEN_HUGGINGFACE"
)

# Ejecutar diarización
diarization = pipeline("~/lab-forense/procesado/evidencia_01_std.wav")

# Mostrar y guardar resultados
segmentos = []
print("\n═══ DIARIZACIÓN — TIMELINE DE HABLANTES ═══\n")
for turn, _, speaker in diarization.itertracks(yield_label=True):
    seg = {
        "hablante": speaker,
        "inicio": round(turn.start, 2),
        "fin": round(turn.end, 2),
        "duracion": round(turn.end - turn.start, 2)
    }
    segmentos.append(seg)
    print(f"  [{seg['inicio']:6.2f}s - {seg['fin']:6.2f}s]  {speaker}")

with open("~/lab-forense/reportes/diarizacion.json", "w") as f:
    json.dump(segmentos, f, indent=2)
print(f"\n✓ {len(segmentos)} segmentos guardados en reportes/diarizacion.json")

#!/usr/bin/env python3
# comparacion_biometrica.py
# Compara la voz de la evidencia con una muestra de referencia

import librosa
import numpy as np
from scipy.spatial.distance import cosine

def extraer_huella_vocal(ruta):
    """Extrae la huella vocal (MFCC) de un archivo de audio."""
    y, sr = librosa.load(ruta, sr=16000)
    # MFCC: representación compacta del timbre vocal
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
    # Estadísticas sobre el tiempo
    huella = np.concatenate([
        np.mean(mfcc, axis=1),
        np.std(mfcc, axis=1)
    ])
    return huella

# Evidencia vs. muestra de referencia
huella_evidencia  = extraer_huella_vocal("~/lab-forense/procesado/voz_separada.wav")
huella_referencia = extraer_huella_vocal("~/lab-forense/evidencia/muestra_referencia.wav")

# Similitud por coseno (1.0 = idéntico, 0.0 = completamente diferente)
similitud = 1 - cosine(huella_evidencia, huella_referencia)
print(f"Similitud biométrica: {similitud:.4f}")

if similitud > 0.85:
    print("✅ COINCIDENCIA ALTA — probable mismo hablante")
elif similitud > 0.65:
    print("🔍 COINCIDENCIA MEDIA — requiere análisis pericial adicional")
else:
    print("❌ COINCIDENCIA BAJA — posiblemente hablantes distintos")

#!/usr/bin/env python3
# generar_informe.py — Informe pericial completo

import json, datetime, hashlib
from pathlib import Path

def cargar_json(path):
    try:
        return json.loads(Path(path).read_text())
    except:
        return {}

informe = {
    "INFORME_PERICIAL": {
        "numero_caso": "CASO-2026-001",
        "fecha_analisis": datetime.datetime.now().isoformat(),
        "perito": "[Tu nombre y número de colegiado]",
        "herramientas": [
            "FFmpeg 6.0", "Python 3.12 + librosa 0.10", "Audacity 3.4"
        ]
    },
    "CADENA_CUSTODIA": cargar_json("~/lab-forense/reportes/cadena_custodia.json"),
    "ANOMALIAS_BITRATE": cargar_json("~/lab-forense/reportes/anomalias.json"),
    "EMPALMES_DETECTADOS": cargar_json("~/lab-forense/reportes/empalmes.json"),
    "DIARIZACION": cargar_json("~/lab-forense/reportes/diarizacion.json"),
    "CONCLUSION": {
        "autenticidad": "[AUTÉNTICO / MANIPULADO / INDETERMINADO]",
        "confianza": "[ALTA / MEDIA / BAJA]",
        "observaciones": "[Texto de conclusión del perito]"
    }
}

salida = Path("~/lab-forense/reportes/informe_final.json").expanduser()
salida.write_text(json.dumps(informe, indent=2, ensure_ascii=False))
print(f"✅ Informe generado: {salida}")