← Laboratorios
🦈 Lab · TLS Analysis · Wireshark

Wireshark — Análisis TLS

Cómo capturar, filtrar y extraer información JA3 de tráfico TLS usando Wireshark y tshark desde la perspectiva del analista SOC.

Filtros de display de Wireshark para aislar tráfico TLS y enfocarse en los Client Hello que producen las huellas JA3. Son distintos de los filtros de captura (BPF).

Filtros esenciales — Client Hello

WIRESHARK DISPLAY FILTER Todos los TLS Client Hello
tls.handshake.type == 1

El tipo de mensaje 1 es siempre un Client Hello. Es el punto de partida para cualquier análisis JA3 — todos los paquetes que aparecen con este filtro son candidatos a generar una huella JA3.

WIRESHARK DISPLAY FILTER Client Hello con versión TLS específica
/* TLS 1.2 Client Hello (0x0303) */
tls.handshake.type == 1 && tls.handshake.version == 0x0303

/* TLS 1.0 Client Hello — inusual en 2024, sospechoso */
tls.handshake.type == 1 && tls.handshake.version == 0x0301

/* Clientes que NO ofrecen TLS 1.3 — potencialmente legacy/malware */
tls.handshake.type == 1 && !(tls.handshake.extensions.supported_version == 0x0304)
Insight SOC: En 2024, cualquier cliente que negocie TLS 1.0 o 1.1 es sospechoso. Muchos malwares usan versiones antiguas para compatibilidad con C2 servers viejos o mal configurados.

Filtrar por Cipher Suites

WIRESHARK DISPLAY FILTER Cipher suites débiles o sospechosas
/* Cipher NULL — sin cifrado, tráfico en claro */
tls.handshake.ciphersuite == 0x0000

/* DES / RC4 — algoritmos rotos desde hace años */
tls.handshake.ciphersuite == 0x0009 || tls.handshake.ciphersuite == 0x0005

/* Sólo 1-4 cipher suites en la lista — típico de tools simples o malware */
tls.handshake.type == 1 && tls.handshake.ciphersuites.count <= 4

/* Client Hello con TLS_RSA_WITH_NULL_MD5 — nunca debería verse */
tls.handshake.ciphersuite == 0x0001

Filtrar por Extensiones TLS

WIRESHARK DISPLAY FILTER Detección de clientes sin extensiones modernas
/* Client Hello sin SNI (Extension 0) — raro en browsers legítimos */
tls.handshake.type == 1 && !(tls.handshake.extensions.type == 0x0000)

/* Sin ALPN — inusual para browsers pero normal en algunos tools */
tls.handshake.type == 1 && !(tls.handshake.extensions.type == 0x0010)

/* Sin session ticket — indica cliente sin persistencia de sesión */
tls.handshake.type == 1 && !(tls.handshake.extensions.type == 0x0023)

/* Buscar SNI específico (dominio sospechoso) */
tls.handshake.extensions_server_name == "evil-c2.example.com"

Filtros combinados para investigación

WIRESHARK DISPLAY FILTER Combinaciones útiles para análisis SOC
/* Todos los Client Hello desde una IP sospechosa */
tls.handshake.type == 1 && ip.src == 192.168.1.105

/* Client Hello hacia puerto no estándar (no 443) — posible C2 */
tls.handshake.type == 1 && tcp.dstport != 443 && tcp.dstport != 8443

/* Client Hello hacia rango de IPs de C2 conocido */
tls.handshake.type == 1 && (ip.dst >= 185.220.0.0 && ip.dst <= 185.220.255.255)

/* Ver flujo completo de una sesión TLS */
tls.handshake.type == 1 && ip.src == 192.168.1.105
/* Luego: clic derecho → Follow → TLS Stream */

Columns útiles para agregar en Wireshark

Campo Field name (para Custom Column) Uso
Versión TLS tls.handshake.version Detectar clientes legacy
SNI (Server Name) tls.handshake.extensions_server_name Ver dominio contactado sin descifrar
ALPN tls.handshake.extensions_alpn_str Protocolo de aplicación (h2, http/1.1, etc.)
Cipher seleccionado tls.handshake.ciphersuite En Server Hello — algoritmo negociado
Cert Subject x509sat.uTF8String CN del certificado del servidor

Wireshark 3.x+ puede mostrar el hash JA3 directamente en el panel de detalle del paquete sin plugins adicionales. También existe el plugin Lua para versiones antiguas.

Método 1 — JA3 nativo en Wireshark 3.3+

Desde Wireshark 3.3, el disector TLS calcula JA3 automáticamente. Para verlo:

  1. Abrí el PCAP con un Client Hello TLS
  2. Seleccioná un paquete con tls.handshake.type == 1
  3. En el panel de detalle, expandí: Transport Layer Security → TLSv1.3 Record Layer → Handshake Protocol: Client Hello → JA3 Fullstring / JA3
  4. El campo JA3 muestra el hash MD5 de 32 chars
WIRESHARK FIELD Filtro de display para el hash JA3
/* Ver solo paquetes con hash JA3 calculado */
tls.handshake.ja3

/* Filtrar por hash JA3 específico — Metasploit */
tls.handshake.ja3 == "e7d705a3286e19ea42f587b344ee6865"

/* Buscar Cobalt Strike default */
tls.handshake.ja3 == "de350869b8c85de67a350c8d186f11e6"

/* Buscar cualquier hash que NO sea browser conocido */
tls.handshake.ja3 && !(
  tls.handshake.ja3 == "773906b0efdefa24a7f2b8eb6985bf37" ||
  tls.handshake.ja3 == "53b7c45e93f5d2f5765a1cf5e61c1e26" ||
  tls.handshake.ja3 == "07f3d598e197f6255e17ef9b0c6cd22a"
)

Método 2 — Script Lua para versiones antiguas

Si usás Wireshark < 3.3, podés instalar el script Lua de JA3:

BASH Instalación del plugin JA3 para Wireshark
# Descargar el plugin oficial de Salesforce
curl -o ~/.config/wireshark/plugins/ja3.lua \
  https://raw.githubusercontent.com/salesforce/ja3/master/wireshark_plugin/ja3.lua

# O en Windows (PowerShell):
# $dest = "$env:APPDATA\Wireshark\plugins\ja3.lua"
# Invoke-WebRequest -Uri "https://raw.githubusercontent.com/salesforce/ja3/main/wireshark_plugin/ja3.lua" -OutFile $dest

# Reiniciar Wireshark y buscar:
# Analyze → Reload Lua Plugins (Ctrl+Shift+L)

Exportar todos los hashes JA3 de un PCAP

WIRESHARK File → Export Packet Dissections → As CSV
/* Paso 1: Aplicar filtro para solo Client Hello con JA3 */
tls.handshake.ja3

/* Paso 2: File → Export Packet Dissections → As CSV */
/* Campos sugeridos: Frame, Time, Source, Destination, JA3 */

/* El CSV resultante permite correlación masiva en Python/Excel */
Tip de análisis: Exportá el CSV a Python con pandas y usá df['ja3'].value_counts() para ver los hashes más frecuentes en tu captura. Un hash muy frecuente proveniente de múltiples IPs puede indicar un C2 distribuido.

tshark es la versión CLI de Wireshark. Ideal para análisis automatizado, scripting y procesamiento de PCAPs grandes en servidores sin GUI. Fundamental para pipelines SOC.

Extracción básica de campos JA3

BASH · tshark Extraer todos los hashes JA3 de un PCAP
# Extraer: timestamp, src_ip, dst_ip, dst_port, ja3_hash, sni
tshark -r captura.pcap \
  -Y "tls.handshake.type == 1" \
  -T fields \
  -e frame.time_epoch \
  -e ip.src \
  -e ip.dst \
  -e tcp.dstport \
  -e tls.handshake.ja3 \
  -e tls.handshake.extensions_server_name \
  -E header=y \
  -E separator=, \
  -E quote=d \
  > ja3_output.csv

# Resultado ejemplo:
# "frame.time_epoch","ip.src","ip.dst","tcp.dstport","tls.handshake.ja3","tls..."
# "1704067200.000","192.168.1.105","185.220.101.4","443","e7d705a3286e19ea42f587b344ee6865","update.evil.com"

Búsqueda de hash JA3 específico en tiempo real

BASH · tshark Captura en vivo — alertar si aparece Metasploit
# Captura en vivo en la interfaz eth0
# Alerta si detecta hash JA3 de Metasploit
tshark -i eth0 \
  -Y "tls.handshake.ja3 == \"e7d705a3286e19ea42f587b344ee6865\"" \
  -T fields \
  -e frame.time \
  -e ip.src \
  -e ip.dst \
  -e tcp.dstport \
  -e tls.handshake.ja3 \
  -e tls.handshake.extensions_server_name \
  2>/dev/null | while IFS= read -r line; do
    echo "[ALERTA JA3 - METASPLOIT] $line"
    # Aquí podrías enviar a Slack, SIEM, o ejecutar un bloqueo automático
  done

Script Python para análisis masivo de JA3

PYTHON Análisis de PCAP con pyshark + correlación de threat intel
#!/usr/bin/env python3
"""
ja3_analyzer.py — Análisis de huellas JA3 en PCAPs
Uso: python3 ja3_analyzer.py captura.pcap
"""
import subprocess
import csv
import sys
from collections import Counter

# ── Base de firmas conocidas (en producción: cargar desde feed) ──
KNOWN_MALICIOUS = {
    "e7d705a3286e19ea42f587b344ee6865": "Metasploit Meterpreter",
    "de350869b8c85de67a350c8d186f11e6": "Cobalt Strike (pre-4.x)",
    "8bab54f22de07d88e90f5e8e5edb5a69": "Emotet C2",
    "19e29534fd49dd27d09234e7b95b86c1": "Dridex / BitPaymer",
}

def extract_ja3(pcap_file):
    """Usa tshark para extraer campos JA3 del PCAP."""
    cmd = [
        "tshark", "-r", pcap_file,
        "-Y", "tls.handshake.type == 1",
        "-T", "fields",
        "-e", "ip.src",
        "-e", "ip.dst",
        "-e", "tcp.dstport",
        "-e", "tls.handshake.ja3",
        "-e", "tls.handshake.extensions_server_name",
        "-E", "separator=|",
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.stdout.strip().split("\n") if result.stdout else []

def analyze(pcap_file):
    records = extract_ja3(pcap_file)
    hashes  = []
    alerts  = []

    for line in records:
        parts = line.split("|")
        if len(parts) < 4 or not parts[3]:
            continue

        src, dst, port, ja3, sni = parts + [""] * (5 - len(parts))
        hashes.append(ja3)

        if ja3 in KNOWN_MALICIOUS:
            alerts.append({
                "hash": ja3, "name": KNOWN_MALICIOUS[ja3],
                "src": src, "dst": dst, "sni": sni or "(sin SNI)"
            })

    print(f"\n=== JA3 Analysis: {pcap_file} ===")
    print(f"Total Client Hello packets: {len(records)}")
    print(f"Unique JA3 hashes: {len(set(hashes))}")

    print("\n── Top 5 hashes más frecuentes ──")
    for h, count in Counter(hashes).most_common(5):
        tag = f"  ⚠ {KNOWN_MALICIOUS[h]}" if h in KNOWN_MALICIOUS else ""
        print(f"  {h}  ×{count}{tag}")

    if alerts:
        print(f"\n🔴 ALERTAS ({len(alerts)} detecciones):")
        for a in alerts:
            print(f"  [{a['name']}] {a['src']} → {a['dst']} (SNI: {a['sni']})")
    else:
        print("\n✅ Sin hashes maliciosos conocidos detectados.")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: python3 ja3_analyzer.py ")
        sys.exit(1)
    analyze(sys.argv[1])

Exportar JA3 con campos de contexto completos

BASH · tshark Todos los campos útiles para correlación en SIEM
# Exportación completa para ingestión en SIEM
tshark -r captura.pcap \
  -Y "tls.handshake.type == 1" \
  -T fields \
  -e frame.number \
  -e frame.time_epoch \
  -e eth.src \
  -e eth.dst \
  -e ip.src \
  -e ip.dst \
  -e tcp.srcport \
  -e tcp.dstport \
  -e tls.handshake.version \
  -e tls.handshake.ja3 \
  -e tls.handshake.ja3_full \
  -e tls.handshake.extensions_server_name \
  -e tls.handshake.extensions_alpn_str \
  -E header=y -E separator=, -E quote=d \
  > siem_ja3_export.csv

Flujo de análisis forense con Wireshark para investigar una alerta de JA3 malicioso. Pasos ordenados por prioridad de tiempo — primero contención, luego análisis profundo.

Checklist de análisis TLS con Wireshark

🎯
Aislar el tráfico del host afectado

Aplicar filtro: ip.src == [IP_SOSPECHOSA] || ip.dst == [IP_SOSPECHOSA]
Verificar volumen de tráfico, cantidad de sesiones TLS y rangos horarios. Un patrón de beacon (tráfico periódico cada N segundos) es indicativo de C2.

🔍
Analizar el Client Hello sospechoso

Filtro: ip.src == [IP] && tls.handshake.type == 1
Expandir en el panel de detalle: ¿cuántas cipher suites ofrece? ¿Tiene SNI? ¿Qué extensiones? Un Client Hello con pocas ciphers y sin SNI es un indicador fuerte de herramienta automatizada.

📋
Registrar el hash JA3 y el SNI

Copiar el hash JA3 del panel de detalle (campo tls.handshake.ja3). Copiar el SNI (tls.handshake.extensions_server_name) — el dominio contactado puede estar en Alexa Top 1M (DGA que mimetiza dominios legítimos) o ser un DGA puro.

🔗
Seguir el flujo TLS completo

Clic derecho en el paquete → Follow → TLS Stream
Si tenés la clave privada del servidor (entorno de lab o corporate proxy), podés descifrar. Sin clave: observar tamaños de Application Data para inferir tipo de payload. Patrones regulares de 300-800 bytes cada 30-60 seg → beacon C2.

📊
Estadísticas de conversaciones

Statistics → Conversations → TCP
Ver duración, bytes transferidos y cantidad de paquetes por sesión. C2 channels suelen tener sesiones largas con bajo volumen de datos (poll de comandos) o sesiones cortas muy frecuentes (beaconing con jitter).

💾
Exportar evidencia

File → Export Specified Packets → guardar el PCAP filtrado al flujo sospechoso.
Hashear el PCAP con SHA256 para cadena de custodia: sha256sum evidencia.pcap
Documentar: timestamp, interfaz de captura, filtros aplicados, hash del archivo.

Comandos rápidos de referencia

ObjetivoFiltro / Comando
Ver todos los Client Hello tls.handshake.type == 1
Ver hash JA3 en display tls.handshake.ja3
Filtrar por JA3 específico tls.handshake.ja3 == "hash32chars"
Client Hello sin SNI tls.handshake.type==1 && !tls.handshake.extensions_server_name
TLS hacia puerto inusual tls.handshake.type==1 && tcp.dstport != 443
Exportar JA3 a CSV (tshark) tshark -r pcap -Y "tls.handshake.type==1" -T fields -e tls.handshake.ja3

PCAPs para práctica

Los PCAPs son capturas de tráfico real o simulado que permiten practicar análisis TLS/JA3 sin necesidad de tráfico en vivo. Esta sección explica cómo generarlos y analizarlos con tshark y Wireshark.

Los PCAPs de esta sección están disponibles como placeholders en laboratorios/tls/pcaps/. Cada archivo explica cómo generar la captura real en tu entorno de laboratorio.

Escenarios disponibles

ESCENARIO 01 · BENIGNO
Chrome TLS 1.2
Tráfico HTTPS típico de navegador. Establece la línea base de JA3 legítimo.
JA3: ada70206...503241d5
📄 Ver instrucciones de captura
ESCENARIO 02 · HERRAMIENTA
curl HTTPS
Tráfico de herramienta CLI. JA3 diferente a Chrome aunque vaya al mismo destino.
JA3: 51c64c77...68c58a8
📄 Ver instrucciones de captura
ESCENARIO 03 · SIMULADO C2
Beacon C2 (simulado)
Simulación de implante C2 con intervalo regular de 5 min. JA3 Cobalt Strike conocido.
JA3: de350869...3b186f11e6 ⚠️
📄 Ver instrucciones (solo lab)

Análisis con tshark

bash Extracción JA3 de PCAP
# Listar todos los Client Hello con JA3
tshark -r traffic.pcap \
  -Y "tls.handshake.type == 1" \
  -T fields \
  -e frame.number \
  -e ip.src \
  -e ip.dst \
  -e tcp.dstport \
  -e tls.handshake.ja3 \
  -e tls.handshake.extensions_server_name

# Contar JA3 únicos
tshark -r traffic.pcap \
  -Y "tls.handshake.type == 1" \
  -T fields -e tls.handshake.ja3 | \
  sort | uniq -c | sort -rn

# Buscar JA3 específico (Cobalt Strike)
tshark -r traffic.pcap \
  -Y "tls.handshake.type == 1" | \
  grep "de350869b8c85de67a350c8d186f11e6"

# Exportar a CSV para análisis
tshark -r traffic.pcap \
  -Y "tls.handshake.type == 1" \
  -T fields \
  -e frame.time \
  -e ip.src -e ip.dst \
  -e tls.handshake.ja3 \
  -E separator=, -E header=y \
  > ja3_export.csv
bash Detección de beaconing en PCAP
# Analizar intervalos entre conexiones al mismo destino
tshark -r malware_beacon_sim.pcap \
  -T fields \
  -e frame.time_epoch \
  -e ip.src \
  -e ip.dst \
  -e tcp.dstport \
  -e tls.handshake.ja3 \
  -Y "tls.handshake.type == 1" | \
  sort -k3,4 | \
  awk 'BEGIN{prev_dst=""; prev_ts=0}
       {
         key=$3":"$4;
         if(key==prev_key) {
           delta=$1-prev_ts;
           printf "Delta %ds → %s→%s:%s JA3:%s\n", delta, $2, $3, $4, $5;
         }
         prev_key=key; prev_ts=$1
       }'
💡 Flujo forense recomendado: Abrí el PCAP en Wireshark → filtrá tls.handshake.type == 1 → revisá JA3 en la columna de detalles → exportá con tshark → comparar contra threat intel feeds.

Continuá el lab TLS: JA3 Core · Snort · QRadar · FortiGate · Teoría TLS

← Volver al inicio