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

HTTP/2 y huellas de cabeceras

Por qué importa Incluso con una huella TLS idéntica, los primeros mensajes HTTP/2 que envía un navegador, y el orden de sus cabeceras, varían entre navegadores. Los sistemas de detección lo usan para comprobar si un cliente es de verdad el navegador que dice su user agent. Distinguirás tres navegadores simulados, y pillarás a un script que se hace pasar por uno.

Dos personas pueden llevar el mismo uniforme y aun así distinguirse por cómo rellenan un formulario: el orden en que escriben las cosas, qué casillas marcan primero. Las aperturas de HTTP/2 son un formulario que cada navegador rellena a su manera.

HTTP/2: una versión más nueva de HTTP que los navegadores usan hoy para la mayoría de los sitios HTTPS, junto con el aún más nuevo HTTP/3. Envía las peticiones como pequeños mensajes binarios llamados frames por una sola conexión, y necesita ALPN h2 en el handshake.

Frame: un mensaje de HTTP/2. Un frame SETTINGS anuncia límites, un frame WINDOW_UPDATE dice cuántos datos está listo para recibir el navegador, y un frame HEADERS lleva las cabeceras de una petición.

Lo que revela la apertura

  • SETTINGS. Una lista de pares (id, valor), como (1, 32768) para el tamaño de una tabla o (4, 4194304) para el tamaño de una ventana. Qué ajustes aparecen, sus valores y su orden los elige el código del navegador.
  • WINDOW_UPDATE. Un número: cuántos datos extra está dispuesto a recibir el navegador.
  • Prioridad. Cómo dice el navegador qué peticiones importan más. Cada navegador lo hace de forma distinta.
  • Orden de las pseudocabeceras. Cada petición HTTP/2 empieza con cuatro cabeceras especiales: :method, :authority (el sitio), :scheme y :path. El protocolo no fija su orden, así que cada navegador elige uno.
  • Orden de las cabeceras. Las cabeceras normales, como user-agent y accept, también llegan en un orden propio de cada navegador.

Una línea para comparar

Una forma habitual de apuntarlo es una línea de texto con cuatro partes separadas por |:

1:32768;3:250;4:4194304;6:131072|10420225|0|m,s,a,p
 settings (id:value;...)         window  prio pseudo-header initials

Las iniciales son la primera letra después de los dos puntos: :method se convierte en m.

Orden y mayúsculas de las cabeceras: escondido a plena vista

En HTTP/2, los nombres de las cabeceras deben enviarse en minúsculas. En el antiguo HTTP/1.1, las mayúsculas dependían de quien enviaba, así que User-Agent frente a user-agent podía por sí solo distinguir clientes. El orden funciona en los dos. En nuestro mundo, Brook y Cobalt están construidos sobre el mismo motor ficticio: su línea de ajustes HTTP/2 es idéntica, y solo cambia el orden de sus cabeceras. Así que necesitas las dos cosas para distinguirlos.

Lo que dice el user agent: la cabecera user-agent es solo un texto que el cliente escribe sobre sí mismo. Cualquier programa puede copiarlo. Los detalles del handshake y de HTTP/2 son más difíciles de falsificar sin querer, así que los detectores los comparan con lo que dice.

El mundo de práctica te da h2_connection(name, seed) para Brook, Cobalt y Fennel, más "Toolkit": un script ficticio que copia el user agent de Brook pero abre HTTP/2 a su manera. Cada conexión es un diccionario con settings, window_update, priority, pseudo_headers, headers (una lista de pares (name, value)) y user_agent. Todos los valores son ficticios.

Para unir pares en un texto: ";".join("%d:%d" % (k, v) for k, v in pairs). Para quedarte con el nombre antes de la barra en "Brook/31.0": ua.split("/")[0].

En otros lenguajes

Construir la parte de ajustes de la línea en otros lenguajes:

// JavaScript
const settings = conn.settings.map(([k, v]) => `${k}:${v}`).join(";");
const pseudo = conn.pseudo_headers.map(h => h[1]).join(",");
const line = [settings, conn.window_update, conn.priority, pseudo].join("|");
// Go
parts := []string{}
for _, s := range conn.Settings {
    parts = append(parts, fmt.Sprintf("%d:%d", s.ID, s.Value))
}
settings := strings.Join(parts, ";")
// C#
var settings = string.Join(";", conn.Settings.Select(s => $"{s.Id}:{s.Value}"));

La defensa

Para los usuarios normales, la protección es la misma que con TLS: usar un navegador común y actual, para que tu apertura de HTTP/2 coincida con la de millones de personas. Para quien construye sitios: si usas estas señales para combatir el fraude, úsalas para añadir fricción (como una segunda comprobación), nunca como prueba de quién es una persona, y nunca para perfilar a la gente.

Resumen

  • La apertura de HTTP/2 de un navegador (ajustes, tamaño de ventana, prioridad, orden de las pseudocabeceras) es una huella digital.
  • El orden de las cabeceras, y en HTTP/1.1 sus mayúsculas, añade más.
  • Dos navegadores sobre el mismo motor pueden compartir los ajustes y diferenciarse solo en el orden de las cabeceras.
  • Los detectores comparan estas señales con lo que dice el user agent para detectar clientes que no son lo que dicen.
Tu turno

Escribe seis funciones cortas:

  1. h2_fingerprint(conn): los ajustes como id:value unidos con ;, luego |, el window_update, |, la priority, | y las iniciales de las pseudocabeceras (el carácter después de los dos puntos) unidas con ,.
  2. header_order(conn): los nombres de las cabeceras, en orden, unidos con ,.
  3. full_fingerprint(conn): h2_fingerprint(conn) + "|" + header_order(conn).
  4. learn(training): a partir de una lista de pares (name, conn), devuelve un diccionario que asocia cada full_fingerprint a su nombre.
  5. identify(conn, known): el nombre que hay en known para la huella completa de esta conexión, o "unknown".
  6. claim_matches(conn, known): True si identify da el mismo nombre que dice el user agent (el texto antes de / en conn["user_agent"]), y si no False.
El informe del final ya está escrito.

¿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.