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).
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.
/* 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.
/* 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
/* 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"
/* 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 */
| 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.
Desde Wireshark 3.3, el disector TLS calcula JA3 automáticamente. Para verlo:
tls.handshake.type == 1JA3 muestra el hash MD5 de 32 chars/* 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"
)
Si usás Wireshark < 3.3, podés instalar el script Lua de JA3:
# 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)
/* 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 conpandasy 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.
# 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"
# 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
#!/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])
# 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.
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.
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.
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.
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.
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).
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.
| Objetivo | Filtro / 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 |
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.
laboratorios/tls/pcaps/. Cada archivo explica cómo generar la captura real en tu entorno de laboratorio.
# 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
# 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
}'
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