Conteúdo do curso Lição 104 de 156 · Impressões digitais de rede
Impressões digitais de rede

Impressões digitais de TLS (JA3 e JA4)

Por que isso importa A detecção de bots e de fraude, e alguns rastreadores, reconhecem navegadores fazendo o hash do ClientHello deles. Escrever você mesmo as duas receitas mais conhecidas mostra exatamente como um navegador pode ser reconhecido antes de qualquer página carregar, e por que uma mudança em um navegador em 2023 quebrou a receita mais antiga.

Aqui, uma impressão digital é como descrever alguém pela ordem exata em que lista suas habilidades. Anote a lista, comprima-a em um código curto, e você pode comparar códigos em vez de listas longas.

Hash: uma função que comprime qualquer texto em um código curto de tamanho fixo. O mesmo texto sempre dá o mesmo código; um texto diferente dá um código diferente. MD5 e SHA-256 são duas funções de hash do hashlib do Python.

JA3: juntar tudo em ordem e depois fazer o hash

O JA3, publicado em 2017, escreve cinco campos como números decimais, junta cada lista com hifens, junta os cinco campos com vírgulas e faz o hash MD5. Os valores GREASE ficam de fora.

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 ele mantém a ordem, dois navegadores que oferecem os mesmos recursos em ordem diferente recebem códigos JA3 diferentes. Isso era um ponto forte, até os navegadores mudarem.

A mudança de 2023: extensões embaralhadas

A partir do Chrome 110 (começo de 2023), o Chrome passou a colocar suas extensões TLS em ordem aleatória em toda conexão (verificado em outubro de 2026). O objetivo era impedir que os servidores dependessem de uma ordem fixa, o que torna o protocolo mais difícil de mudar. Um efeito colateral: o código JA3 do Chrome passou a ser diferente em quase toda conexão, então o JA3 não conseguia mais reconhecê-lo como uma coisa só.

JA4: ordenar primeiro e depois fazer o hash

O JA4, lançado em 2023, resolve isso ordenando as cipher suites e as extensões antes do hash, então embaralhar não faz diferença. Ele também começa com uma parte curta e legível. Um código JA4 tem este formato (os dois hashes aqui são inventados): t13d1516h2_1a2b3c4d5e6f_0f9e8d7c6b5a:

  • t para TCP, 13 para TLS 1.3, d porque um nome de domínio foi enviado (i se não foi), 15 cipher suites, 16 extensões, h2 a partir do primeiro e do último caractere do primeiro valor de ALPN.
  • Depois os 12 primeiros caracteres hexadecimais de um SHA-256 das cipher suites ordenadas.
  • Depois 12 caracteres das extensões ordenadas (sem o nome do servidor e o ALPN, que dependem do site, não do navegador).

Nosso laboratório monta um código simplificado no estilo JA4 com as mesmas três partes. O JA4 real também inclui os algoritmos de assinatura na última parte; nós os deixamos de fora para ficar curto. Uma nota de licença para quem constrói: o JA4 (a impressão digital do cliente TLS) está sob a licença BSD, enquanto a maior parte do resto da família JA4+ usa a licença FoxIO (verificado em outubro de 2026).

O Python de que você precisa

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'

O mundo de prática dá a você client_hello(browser, connection, seed) para três navegadores fictícios: Brook (acrescenta GREASE e embaralha as extensões), Cobalt (acrescenta GREASE, ordem fixa) e Fennel (nenhum dos dois). Os números deles são códigos reais do registro em combinações que nenhum navegador real usa, então nada aqui imita um navegador real. GREASE é o conjunto de valores GREASE.

Em outras linguagens

Ferramentas de impressão digital em muitas linguagens calculam JA3 e JA4. O núcleo do JA3 em algumas delas:

// 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];

A defesa

Você não tem como parar de enviar um ClientHello. O que protege as pessoas comuns é ser comum: um navegador popular e atualizado compartilha sua impressão digital com milhões de outros, então ela diz pouco sobre você. Uma configuração incomum, como um navegador antigo ou muito modificado, se destaca. A lição 106 volta a isso.

Resumo

  • O JA3 junta os campos do ClientHello em ordem e faz um MD5; ele pula o GREASE.
  • O Chrome passou a embaralhar a ordem das extensões no Chrome 110 (começo de 2023), o que fez o JA3 dele mudar a cada conexão.
  • O JA4 ordena as cipher suites e as extensões antes do hash, então mudanças de ordem não importam.
  • Um navegador comum e atualizado compartilha sua impressão digital com muita gente, e essa é a proteção real.
Sua vez

Cada hello é um dict de client_hello(...) com version, supported_versions, ciphers, extensions, groups, point_formats, sni e alpn. Escreva quatro funções:

  1. strip_grease(values): uma nova lista sem nenhum valor que esteja em GREASE, na ordem original.
  2. ja3_string(hello): version, depois ciphers, extensions, groups e point_formats, cada um sem GREASE e juntado com -; os cinco campos juntados com ,.
  3. ja3(hello): o hex digest MD5 de ja3_string(hello).
  4. ja4_style(hello): três partes juntadas com _. A parte a é t, depois 13 se 772 estiver em supported_versions, senão 12, depois d se sni estiver definido, senão i, depois a quantidade de cifras e a quantidade de extensões (sem GREASE) com dois dígitos cada, depois o primeiro e o último caractere do primeiro valor de ALPN (00 se a lista estiver vazia). A parte b são os 12 primeiros caracteres do hex digest SHA-256 das cifras ordenadas, cada uma escrita como hexadecimal de 4 dígitos ("%04x") e juntadas com ,. A parte c é o mesmo para as extensões ordenadas, deixando de fora 0 e 16.
A comparação impressa no fim já está escrita para você.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.