Temario Lección 104 de 156 · Huellas digitales de red
Huellas digitales de red

Huellas digitales de TLS (JA3 y JA4)

Por qué importa La detección de bots y de fraude, y algunos rastreadores, reconocen los navegadores calculando un hash de su ClientHello. Escribir tú mismo las dos recetas más conocidas muestra exactamente cómo se puede reconocer un navegador antes de que se cargue ninguna página, y por qué un cambio en un navegador en 2023 rompió la receta más antigua.

Aquí, una huella digital es como describir a alguien por el orden exacto en que enumera sus habilidades. Apunta la lista, comprímela en un código corto y podrás comparar códigos en lugar de listas largas.

Hash: una función que comprime cualquier texto en un código corto de tamaño fijo. El mismo texto siempre da el mismo código; un texto distinto da un código distinto. MD5 y SHA-256 son dos funciones hash del hashlib de Python.

JA3: unirlo todo en orden y luego calcular el hash

JA3, publicado en 2017, escribe cinco campos como números decimales, une cada lista con guiones, une los cinco campos con comas y calcula el hash MD5. Los valores GREASE se dejan fuera.

version,ciphers,extensions,groups,point_formats
771,4866-4865-4867-49196,0-10-11-13-16,29-23-25-24,0     (shortened)
md5 -> a 32-character hex code

Como conserva el orden, dos navegadores que ofrecen las mismas funciones en otro orden obtienen códigos JA3 distintos. Eso era una ventaja, hasta que los navegadores cambiaron.

El cambio de 2023: extensiones barajadas

A partir de Chrome 110 (principios de 2023), Chrome empezó a poner sus extensiones TLS en un orden aleatorio en cada conexión (comprobado en octubre de 2026). El objetivo era que los servidores dejaran de depender de un orden fijo, lo que hace más difícil cambiar el protocolo. Un efecto secundario: el código JA3 de Chrome pasó a ser distinto en casi cada conexión, así que JA3 ya no podía reconocerlo como una sola cosa.

JA4: ordenar primero y luego calcular el hash

JA4, publicado en 2023, lo resuelve ordenando las suites de cifrado y las extensiones antes de calcular el hash, así que barajarlas no cambia nada. Además empieza con una parte corta legible. Un código JA4 tiene esta forma (los dos hashes de aquí son inventados): t13d1516h2_1a2b3c4d5e6f_0f9e8d7c6b5a:

  • t por TCP, 13 por TLS 1.3, d porque se envió un nombre de dominio (i si no), 15 suites de cifrado, 16 extensiones, h2 a partir del primer y el último carácter del primer valor ALPN.
  • Luego los primeros 12 caracteres hexadecimales de un SHA-256 de las suites de cifrado ordenadas.
  • Luego 12 caracteres de las extensiones ordenadas (sin el nombre del servidor ni ALPN, que dependen del sitio, no del navegador).

Nuestro laboratorio construye un código simplificado al estilo JA4 con las mismas tres partes. El JA4 real también incluye los algoritmos de firma en la última parte; los dejamos fuera para que sea corto. Una nota sobre licencias para quien construya: JA4 (la huella del cliente TLS) tiene licencia BSD, mientras que la mayor parte del resto de la familia JA4+ usa la licencia FoxIO (comprobado en octubre de 2026).

El Python que necesitas

import hashlib
hashlib.md5("abc".encode()).hexdigest()          # 32 hex characters
hashlib.sha256("abc".encode()).hexdigest()[:12]  # first 12
"-".join(str(n) for n in [771, 4865])            # '771-4865'
"%04x" % 4865                                     # '1301' (4-digit hex)
"%02d" % 7                                        # '07'

El mundo de práctica te da client_hello(browser, connection, seed) para tres navegadores ficticios: Brook (añade GREASE y baraja sus extensiones), Cobalt (añade GREASE, orden fijo) y Fennel (ninguna de las dos cosas). Sus números son códigos reales del registro en combinaciones que ningún navegador real usa, así que nada de esto imita a un navegador real. GREASE es el conjunto de valores GREASE.

En otros lenguajes

Hay herramientas de huellas digitales en muchos lenguajes que calculan JA3 y JA4. El núcleo de JA3 en algunos de ellos:

// JavaScript (Node.js)
const crypto = require("crypto");
const clean = xs => xs.filter(x => !GREASE.has(x)).join("-");
const s = [h.version, clean(h.ciphers), clean(h.extensions),
           clean(h.groups), clean(h.point_formats)].join(",");
const ja3 = crypto.createHash("md5").update(s).digest("hex");
// Go
sum := md5.Sum([]byte(s))
ja3 := hex.EncodeToString(sum[:])
// sorting for JA4: sort.Slice(ciphers, func(i, j int) bool { return ciphers[i] < ciphers[j] })
// Rust (sha2 crate)
use sha2::{Digest, Sha256};
let mut c = ciphers.clone();
c.sort();
let text = c.iter().map(|n| format!("{:04x}", n)).collect::<Vec<_>>().join(",");
let part_b = &format!("{:x}", Sha256::digest(text.as_bytes()))[..12];

La defensa

No puedes dejar de enviar un ClientHello. Lo que protege a la gente normal es ser común: un navegador popular y actualizado comparte su huella con millones de personas, así que dice poco de ti. Una configuración poco habitual, como un navegador antiguo o muy modificado, llama la atención. La lección 106 vuelve sobre esto.

Resumen

  • JA3 une los campos del ClientHello en orden y calcula un MD5; se salta GREASE.
  • Chrome empezó a barajar el orden de sus extensiones en Chrome 110 (principios de 2023), lo que hizo que su JA3 cambiara en cada conexión.
  • JA4 ordena las suites de cifrado y las extensiones antes de calcular el hash, así que los cambios de orden no importan.
  • Un navegador común y actualizado comparte su huella con mucha gente, y esa es la protección real.
Tu turno

Cada hello es un diccionario de client_hello(...) con version, supported_versions, ciphers, extensions, groups, point_formats, sni y alpn. Escribe cuatro funciones:

  1. strip_grease(values): una lista nueva sin ningún valor que esté en GREASE, en el orden original.
  2. ja3_string(hello): version, y luego ciphers, extensions, groups y point_formats, cada uno sin GREASE y unido con -; los cinco campos unidos con ,.
  3. ja3(hello): el resumen hexadecimal MD5 de ja3_string(hello).
  4. ja4_style(hello): tres partes unidas con _. La parte a es t, luego 13 si 772 está en supported_versions y si no 12, luego d si sni tiene valor y si no i, luego el número de suites de cifrado y el número de extensiones (sin GREASE) con dos dígitos cada uno, y luego el primer y el último carácter del primer valor ALPN (00 si la lista está vacía). La parte b son los primeros 12 caracteres del resumen hexadecimal SHA-256 de las suites de cifrado ordenadas, cada una escrita como hexadecimal de 4 dígitos ("%04x") y unidas con ,. La parte c es lo mismo para las extensiones ordenadas, dejando fuera el 0 y el 16.
La comparación que se imprime al final ya está escrita.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.