Programme Leçon 104 sur 156 · Les empreintes réseau
Les empreintes réseau

Les empreintes TLS (JA3 et JA4)

Pourquoi c'est important La détection des robots et de la fraude, et certains traqueurs, reconnaissent les navigateurs en hachant leur ClientHello. Écrire toi-même les deux recettes les plus connues montre exactement comment un navigateur peut être reconnu avant qu'une page se charge, et pourquoi un changement d'un navigateur en 2023 a cassé l'ancienne recette.

Une empreinte, ici, c'est comme décrire quelqu'un par l'ordre exact dans lequel il liste ses compétences. Note la liste, comprime-la en un code court, et tu peux comparer des codes au lieu de longues listes.

Hash : une fonction qui comprime n'importe quel texte en un code court de taille fixe. Le même texte donne toujours le même code ; un texte différent donne un code différent. MD5 et SHA-256 sont deux fonctions de hachage du hashlib de Python.

JA3 : tout joindre dans l'ordre, puis hacher

JA3, publié en 2017, écrit cinq champs en nombres décimaux, relie chaque liste par des tirets, relie les cinq champs par des virgules, et prend le hash MD5. Les valeurs GREASE sont exclues.

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

Comme il garde l'ordre, deux navigateurs qui proposent les mêmes fonctions dans un ordre différent obtiennent des codes JA3 différents. C'était une force, jusqu'à ce que les navigateurs changent.

Le changement de 2023 : des extensions mélangées

À partir de Chrome 110 (début 2023), Chrome a commencé à mettre ses extensions TLS dans un ordre aléatoire à chaque connexion (vérifié en octobre 2026). Le but était d'empêcher les serveurs de dépendre d'un ordre fixe, ce qui rend le protocole plus difficile à faire évoluer. Effet secondaire : le code JA3 de Chrome est devenu différent à presque chaque connexion, donc JA3 ne pouvait plus le reconnaître comme une seule chose.

JA4 : trier d'abord, puis hacher

JA4, sorti en 2023, corrige ça en triant les suites de chiffrement et les extensions avant le hachage, donc le mélange ne change rien. Il commence aussi par une courte partie lisible. Un code JA4 a cette forme (les deux hashes ici sont inventés) : t13d1516h2_1a2b3c4d5e6f_0f9e8d7c6b5a :

  • t pour TCP, 13 pour TLS 1.3, d parce qu'un nom de domaine a été envoyé (i sinon), 15 suites de chiffrement, 16 extensions, h2 d'après le premier et le dernier caractère de la première valeur ALPN.
  • Puis les 12 premiers caractères hexadécimaux d'un SHA-256 des suites de chiffrement triées.
  • Puis 12 caractères venant des extensions triées (sans le nom du serveur ni l'ALPN, qui dépendent du site, pas du navigateur).

Notre labo construit un code simplifié de style JA4 avec les trois mêmes parties. Le vrai JA4 inclut aussi les algorithmes de signature dans la dernière partie ; on les laisse de côté pour rester court. Une note de licence pour les constructeurs : JA4 (l'empreinte du client TLS) est sous licence BSD, tandis que la plupart du reste de la famille JA4+ utilise la licence FoxIO (vérifié en octobre 2026).

Le Python dont tu as besoin

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'

Le monde d'entraînement te donne client_hello(browser, connection, seed) pour trois navigateurs fictifs : Brook (ajoute du GREASE et mélange ses extensions), Cobalt (ajoute du GREASE, ordre fixe) et Fennel (ni l'un ni l'autre). Leurs nombres sont de vrais codes du registre dans des combinaisons qu'aucun vrai navigateur n'utilise, donc rien ici n'imite un vrai navigateur. GREASE est l'ensemble des valeurs GREASE.

Dans d'autres langages

Des outils d'empreinte dans beaucoup de langages calculent JA3 et JA4. Le cœur de JA3 dans quelques-uns :

// 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 défense

Tu ne peux pas arrêter d'envoyer un ClientHello. Ce qui protège les gens ordinaires, c'est d'être courant : un navigateur populaire et à jour partage son empreinte avec des millions d'autres, donc elle dit peu de choses sur toi. Une configuration inhabituelle, comme un navigateur ancien ou très modifié, se remarque. La leçon 106 y revient.

Récap

  • JA3 relie les champs du ClientHello dans l'ordre et prend un MD5 ; il saute le GREASE.
  • Chrome a commencé à mélanger l'ordre de ses extensions avec Chrome 110 (début 2023), ce qui a fait changer son JA3 à chaque connexion.
  • JA4 trie les suites de chiffrement et les extensions avant le hachage, donc les changements d'ordre n'ont pas d'importance.
  • Un navigateur courant et à jour partage son empreinte avec beaucoup de gens, c'est la vraie protection.
À ton tour

Chaque hello est un dict venant de client_hello(...) avec version, supported_versions, ciphers, extensions, groups, point_formats, sni et alpn. Écris quatre fonctions :

  1. strip_grease(values) : une nouvelle liste sans aucune valeur de GREASE, dans l'ordre d'origine.
  2. ja3_string(hello) : version, puis ciphers, extensions, groups et point_formats, chacun sans GREASE et relié par - ; les cinq champs reliés par ,.
  3. ja3(hello) : le condensé MD5 en hexadécimal de ja3_string(hello).
  4. ja4_style(hello) : trois parties reliées par _. La partie a est t, puis 13 si 772 est dans supported_versions sinon 12, puis d si sni est renseigné sinon i, puis le nombre de suites de chiffrement et le nombre d'extensions (sans GREASE) sur deux chiffres chacun, puis le premier et le dernier caractère de la première valeur ALPN (00 si la liste est vide). La partie b est formée des 12 premiers caractères du condensé SHA-256 en hexadécimal des suites de chiffrement triées, chacune écrite en hexadécimal sur 4 chiffres ("%04x") et reliées par ,. La partie c est pareille pour les extensions triées, sans 0 ni 16.
La comparaison affichée en bas est écrite pour toi.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.