Retour aux mises à jour
New releaseSep 1, 2026

ja4 v1.0.1

JA4+ est une suite de normes de fingerprinting réseau

Partager

logo

Empreinte réseau JA4+™

JA4+ est une suite de méthodes d'empreinte réseau par FoxIO qui sont faciles à utiliser et à partager. Ces méthodes sont à la fois lisibles par l'humain et par la machine pour faciliter une chasse aux menaces et une analyse plus efficaces. Les cas d'utilisation de ces empreintes incluent la recherche d'acteurs de menaces, la détection de logiciels malveillants, la prévention du détournement de session, l'automatisation de la conformité, le suivi de localisation, la détection DDoS, le regroupement d'acteurs de menaces, la détection de shells inversés, et bien d'autres encore.

Pour une explication rapide de JA4+ et à utiliser comme référence lors de l'analyse, voir :
JA4+ Cheat Sheet

Pour des détails approfondis, veuillez lire nos blogs sur le fonctionnement de JA4+, pourquoi il fonctionne, et des exemples de ce qui peut être détecté/prévenu avec :
Empreinte réseau JA4+ (JA4/S/H/L/X/SSH)
JA4T : Empreinte TCP (JA4T/TS/TScan)
Enquête sur Surfshark et NordVPN avec JA4T (JA4T)
JA4D et JA4D6 : Empreinte DHCP (JA4D/6)

Si vous aimez JA4+, pensez à acheter un t-shirt ou un sweat à capuche :
T-shirts, sweats à capuche et autocollants JA4+

Table des matières

Méthodes actuelles et détails d'implémentation

Nom completNom courtDescription
JA4JA4Empreinte client TLS
JA4ServerJA4SEmpreinte de réponse serveur / session TLS
JA4HTTPJA4HEmpreinte client HTTP
JA4LatencyJA4LMesure de latence client vers serveur / distance lumineuse
JA4LatencyServerJA4LSMesure de latence serveur vers client / distance lumineuse
JA4X509JA4XEmpreinte de certificat TLS X509
JA4SSHJA4SSHEmpreinte de trafic SSH
JA4TCPJA4TEmpreinte client TCP
JA4TCPServerJA4TSEmpreinte de réponse serveur TCP
JA4TCPScanJA4TScanScanner actif d'empreintes TCP
JA4DHCPJA4DEmpreinte DHCP
JA4DHCPv6JA4D6Empreinte DHCPv6
JA4NTPJA4NEmpreinte NTP
JA4Scan-TLSJA4Scan-TLSScanner actif d'empreintes de serveur TLS
JA4Scan-QUICJA4Scan-QUICScanner actif d'empreintes de serveur QUIC

Le nom complet ou le nom court peuvent être utilisés de manière interchangeable. Des méthodes JA4+ supplémentaires sont en cours de développement...

Pour comprendre comment lire les empreintes JA4+, voir Détails techniques

Implémentations

Ce dépôt inclut JA4+ en

Outils prenant en charge JA4+

Outil/FournisseurPrise en charge JA4+
WiresharkJA4+
ZeekJA4+
ArkimeJA4+ (notre outil open source JA4+ recommandé)
SuricataJA4+ (en cours de développement)
GreyNoiseJA4+
HuntJA4+
DriftnetJA4+
GoLang (1)JA4X
GoLang (2)JA4
nzymeJA4+ (en cours de développement)
CapLoader de NetresecJA4+ (en cours de développement)
NetworkMiner de NetresecJA4+ (en cours de développement)
NGINXJA4+
F5 BIG-IPJA4+
nfdumpJA4+
ntopng de ntopJA4+
nDPI de ntopJA4
Team CymruJA4+
NetQuestJA4+
CensysJA4+
Netryx d'Exploit.orgJA4 et JA4H
CloudflareJA4
FastlyJA4+ (demandez-le)
MISPJA4+
OCSFJA4+
VercelJA4
SeikaJA4+
VirusTotalJA4
AWS CloudfrontJA4
ELLIOJA4+
WebscoutJA4+
RamaJA4 et JA4H
VectraJA4+
AWS WAFJA4
TacticlyJA4+
Palo Alto NetworksJA4+
ngrokJA4
Vertex SynapseJA4 et JA4S
Google Cloud ArmorJA4
FortinetJA4
AppOmniJA4+
IntelliGenesisJA4+
HAProxyJA4 et JA4H plugins par OXL
SentinelOneJA4
AkamaiJA4
Alibaba CloudJA4
Huawei CloudJA4
Google Cloud LBsJA4
eSentireJA4+
Microsoft Azure Front Door CDNJA4
Synapse par Gen0SecJA4X
ZscalerJA4
ExtraHopJA4+
ValidinJA4+
Auth0JA4
Security OnionJA4+
bunny.netJA4
ENEAJA4+
F5 Distributed Cloud ServicesJA4+

avec plus à annoncer...

Exemples

ApplicationEmpreintes JA4+
ChromeJA4=t13d1517h2_8daaf6152771_cb7bf5808d99 (TCP)
JA4=q13d0312h3_55b375c5d22e_178839b6cec1 (QUIC)
Dropper de logiciel malveillant IcedIDJA4H=ge11cn020000_9ed1ff1f7b03_cd8dafe26982
Logiciel malveillant IcedIDJA4=t13d201100_2b729b4bf6f3_9e7b989ebec8
JA4S=t120300_c030_5e2616a54c73
Logiciel malveillant SliverJA4=t13d190900_9dc949149365_97f8aa674fd9
JA4S=t130200_1301_a56c5b993250
JA4X=000000000000_4f24da86fad6_bf0f0589fc03
JA4X=000000000000_7c32fa18c13e_bf0f0589fc03
Cobalt StrikeJA4H=ge11cn060000_4e59edc1297a_4da5efaf0cbd
JA4X=2166164053c1_2166164053c1_30d204a01551
SoftEther VPNJA4=t13d880900_fcb5b95cb75a_b0d3b4ac2a14 (client)
JA4S=t130200_1302_a56c5b993250
JA4X=d55f458d5a6c_d55f458d5a6c_0fc8c171b6ae
QakbotJA4X=2bab15409345_af684594efb4_000000000000
PikabotJA4X=1a59268f55e5_1a59268f55e5_795797892f9c
DarkgateJA4H=po10nn060000_cdb958d032b0
LummaC2JA4H=po11nn050000_d253db9d024b
EvilginxJA4=t13d191000_9dc949149365_e7c285222651
Shell SSH inverséJA4SSH=c76s76_c71s59_c0s70
Windows 11JA4T=64240_2-1-3-1-1-4_1460_8
Imprimante EpsonJA4TScan=28960_2-4-8-1-3_1460_3_1-4-8-16
Windows 11JA4D=disco0000in_61-12-60-55_1-3-6-15-31-33-43-44-46-47-119-121-249-252
Récepteur SonyJA4D6=solct0010nn_8-1-3-6_24-23

Pour plus d'exemples, voir ja4plus-mapping.csv
Pour une base de données complète, voir ja4db.com

Plugins

Wireshark
Zeek
Arkime

Binaires

Les binaires JA4 sont construits à partir de l'implémentation Rust de la suite. Pour garantir une fonctionnalité complète, tshark (version 4.0.6 ou ultérieure) est requis. Téléchargez les derniers binaires JA4 depuis la page Releases. Les versions de publication pour l'implémentation Rust suivent le Versionnement sémantique et sont marquées comme vX.Y.Z, contrairement aux versions du plugin Wireshark.

Actifs de version

Les actifs de version sont nommés selon le composant et la plateforme :

  • Rust :
    • ja4-vX.Y.Z-<architecture>-<plateforme>.tar.gz (par exemple, ja4-v0.18.5-x86_64-unknown-linux-musl.tar.gz)
  • Python :
    • ja4-python-vX.Y.Z.tar.gz (contient le répertoire complet python/)
  • Wireshark :
    • ja4.so.linux, ja4.so.macos, ja4.dll (attachés à une version nommée comme wireshark-vX.Y.Z)

Choisissez le fichier approprié pour votre système et votre composant.

Installation de tshark

Linux

Installez-le à l'aide de votre gestionnaire de paquets (le nom du paquet tshark ou wireshark-cli dépend de la distribution). Par exemple, sur Ubuntu :```sh sudo apt install tshark

#### macOS

1. [Téléchargez](https://www.wireshark.org/download.html) et installez Wireshark (inclut `tshark`).
2. Ajoutez `tshark` à votre `PATH` :   ```sh
   sudo ln -s /Applications/Wireshark.app/Contents/MacOS/tshark /usr/local/bin/tshark

Windows

  1. Téléchargez et installez Wireshark (inclut tshark.exe).
  2. Localisez tshark.exe (généralement dans C:\Program Files\Wireshark\tshark.exe).
  3. Ajoutez le dossier contenant tshark.exe à votre PATH système :
    • Ouvrez Propriétés système > Variables d'environnement > Modifier le chemin.

Exécution de JA4+

Une fois tshark et les binaires JA4+ disponibles, exécutez JA4+ à l'aide de la commande suivante :

  • Sous Linux et macOS : ```sh ./ja4 [options] [pcap]
  • Sous Windows, ouvrez l'Invité de commandes et exécutez : ```cmd ja4 [options] [pcap]

Pour plus de détails sur l'exécution de JA4+ et ses configurations avancées, consultez le README de l'implémentation Rust, qui fournit des informations sur ses fonctionnalités, ses scénarios d'utilisation et ses options de personnalisation.

Base de données

La base de données officielle JA4+ des empreintes, des applications associées et de la logique de détection recommandée se trouve ici : ja4db.com
Cette base de données est en cours de développement très actif. Attendez-vous à des ordres de grandeur supplémentaires de combinaisons d'empreintes et de données au cours des prochains mois.

Un exemple de ja4plus-mapping.csv est également disponible pour une référence rapide.

Processus de publication

JA4+ utilise GitHub Actions pour automatiser les publications de ses composants Rust, Python, Wireshark et Zeek. Les publications sont créées en poussant une balise avec un préfixe spécifique vers le dépôt, sauf pour Zeek, qui utilise une balise de version sémantique (semver) pure. Les artefacts de publication sont nommés comme suit :

  • Rust : ja4-vX.Y.Z-<architecture>-<plateforme>.tar.gz
  • Python : ja4-python-vX.Y.Z.tar.gz
  • Wireshark : ja4.so.linux, ja4.so.macos, ja4.dll (dans une publication nommée comme wireshark-vX.Y.Z)

Les workflows suivants sont disponibles :

  • Publication Rust :
    Poussez une balise commençant par rust-, par exemple rust-v0.18.5, pour déclencher une publication des binaires Rust. Le workflow compilera et téléversera automatiquement les artefacts de publication.

  • Publication Python :
    Poussez une balise commençant par python-, par exemple python-v0.1.0, pour déclencher une publication de l'implémentation Python. Le workflow créera une archive tar du répertoire python/ et la publiera comme artefact de publication.

  • Publication du plugin Wireshark :
    Poussez une balise commençant par wireshark-, par exemple wireshark-v0.1.1, pour déclencher une publication des binaires du plugin Wireshark pour toutes les plateformes prises en charge.

  • Publication Zeek :
    Poussez une balise qui est une version sémantique pure (par exemple v1.2.3), sans préfixe, pour déclencher une publication Zeek. Cela créera automatiquement une publication sur packages.zeek.org.

Comment créer une publication

  1. Assurez-vous que vos modifications sont fusionnées dans la branche main.

  2. Créez et poussez une balise pour le composant que vous souhaitez publier :

    • Pour Rust, Python ou Wireshark, utilisez le préfixe approprié (par exemple rust-v0.18.5, python-v0.1.0, wireshark-v0.1.1).
    • Pour Zeek, utilisez une balise semver pure (par exemple v1.2.3).

    Exemple : ```sh git tag v1.2.3 git push origin v1.2.3

(Pour Zeek)

Ou, pour Rust : ```sh git tag rust-v0.18.5 git push origin rust-v0.18.5

3. Le workflow GitHub Actions correspondant s'exécutera et publiera automatiquement les artefacts de la version. Pour Zeek, la version apparaîtra sur [packages.zeek.org](https://packages.zeek.org/).

## Détails de JA4+

JA4+ est un ensemble d'empreintes réseau simples mais puissantes pour plusieurs protocoles, à la fois lisibles par l'humain et par la machine, facilitant une meilleure chasse aux menaces et une analyse de sécurité améliorée. Si vous n'êtes pas familier avec l'empreinte réseau, je vous encourage à lire mes articles de blog publiant JA3 [ici](https://medium.com/salesforce-engineering/tls-fingerprinting-with-ja3-and-ja3s-247362855967), JARM [ici](https://medium.com/salesforce-engineering/easily-identify-malicious-servers-on-the-internet-with-jarm-e095edac525a), et cet excellent article de Fastly sur l'[État de l'empreinte TLS](https://www.fastly.com/blog/the-state-of-tls-fingerprinting-whats-working-what-isnt-and-whats-next) qui décrit l'historique des méthodes susmentionnées ainsi que leurs problèmes. JA4+ apporte un support dédié, en maintenant les méthodes à jour à mesure que l'industrie évolue.

Toutes les empreintes JA4+ ont un format a_b_c, délimitant les différentes sections qui composent l'empreinte. Cela permet la chasse et la détection en utilisant uniquement ab ou ac ou c seulement. Si l'on souhaitait simplement faire une analyse sur les cookies entrants dans son application, on regarderait uniquement JA4H_c. Ce nouveau format préservant la localité facilite une analyse plus approfondie et plus riche tout en restant simple, facile à utiliser et extensible.

Par exemple, GreyNoise est un écouteur internet qui identifie les scanners internet et implémente JA4+ dans son produit. Ils ont un acteur qui scanne internet avec un seul chiffrement TLS en constante évolution. Cela génère une quantité massive d'empreintes JA3 complètement différentes, mais avec JA4, seule la partie b de l'empreinte JA4 change, les parties a et c restent identiques. Ainsi, GreyNoise peut suivre l'acteur en regardant l'empreinte JA4_ac (en joignant a+c, en supprimant b).

Pour une liste des méthodes JA4+ et leurs descriptions, voir [Méthodes actuelles et détails d'implémentation](#current-methods-and-implementation-details).

Pour comprendre comment lire les empreintes JA4+, voir [Détails techniques](https://github.com/foxio-llc/ja4/blob/main/technical_details/README.md).

## Licence

*JA4 : Empreinte client TLS* est [open-source, BSD 3-Clause](https://github.com/foxio-llc/ja4/blob/main/LICENSE-JA4), tout comme JA3. FoxIO n'a pas de revendications de brevet et ne prévoit pas de poursuivre une couverture par brevet pour l'empreinte client TLS JA4. Cela permet à toute entreprise ou outil utilisant actuellement JA3 de passer immédiatement à JA4 sans délai.

**JA4S, JA4L, JA4LS, JA4L-Delta, JA4H, JA4X, JA4SSH, JA4T, JA4TS, JA4TScan, JA4D, JA4D6, JA4Scan-TLS, JA4Scan-QUIC, JA4N et toutes les futures ajouts (collectivement appelés JA4+)** sont en attente de brevet et sous licence [FoxIO License 1.1](https://github.com/foxio-llc/ja4/blob/main/LICENSE). Cette licence est permissive pour la plupart des cas d'utilisation, y compris pour des fins académiques et commerciales internes, mais n'est pas permissive pour la monétisation. Si, par exemple, une entreprise souhaite utiliser JA4+ en interne pour aider à sécuriser sa propre entreprise, cela est autorisé. Si, par exemple, un fournisseur souhaite vendre l'empreinte JA4+ dans le cadre de son offre de produits, il devra demander une licence OEM auprès de nous.

JA4+ est une marque déposée de FoxIO

JA4+ peut être et est implémenté dans des outils open-source, voir la [FAQ sur la licence](https://github.com/foxio-llc/ja4/blob/main/License%20FAQ.md) pour plus de détails.

Cette licence nous permet de fournir JA4+ au monde d'une manière ouverte et immédiatement utilisable, mais nous offre également un moyen de financer le support continu, la recherche de nouvelles méthodes et le développement de la base de données JA4+. Nous voulons que chacun ait la possibilité d'utiliser JA4+ et nous sommes heureux de travailler avec les fournisseurs et les projets open-source pour y parvenir.

## Q&R

Q : Pourquoi triez-vous les chiffrements ? L'ordre n'a-t-il pas d'importance ?  
R : Il en a, mais dans nos recherches, nous avons constaté que les applications et les bibliothèques choisissent une liste de chiffrements unique plus qu'un ordre unique. Cela réduit également l'efficacité du « cipher stunting », une tactique consistant à randomiser l'ordre des chiffrements pour empêcher la détection JA3.

Q : Pourquoi triez-vous les extensions ?  
R : Plus tôt en 2023, Google a [mis à jour les navigateurs Chromium](https://chromestatus.com/feature/5124606246518784) pour randomiser leur ordre d'extensions. Tout comme le cipher stunting, c'était une tactique pour empêcher la détection JA3 et « rendre l'écosystème TLS plus robuste aux changements ». Google craignait que les implémenteurs de serveurs supposent que l'empreinte Chrome ne changerait jamais et finissent par construire une logique autour d'elle, ce qui causerait des problèmes chaque fois que Google mettrait à jour Chrome.

Je veux donc être clair : les empreintes JA4 changeront à mesure que les bibliothèques TLS des applications seront mises à jour, environ une fois par an. Ne supposez pas que les empreintes resteront constantes dans un environnement où les applications sont mises à jour. Dans tous les cas, trier les extensions contourne ce problème et l'ajout des algorithmes de signature préserve l'unicité.

Q : TLS 1.3 ne rend-il pas l'empreinte des clients TLS plus difficile ?  
R : Non, cela le rend plus facile ! Depuis TLS 1.3, les clients ont un ensemble d'extensions beaucoup plus large et même si TLS 1.3 ne prend en charge que quelques chiffrements, les navigateurs et les applications en prennent en charge beaucoup plus.

## JA4+ a été créé par

[John Althouse](https://www.linkedin.com/in/johnalthouse/), avec les retours de :

Josh Atkins  
Jeff Atkinson  
Joshua Alexander  
W.  
Joe Martin  
Ben Higgins  
Andrew Morris  
Chris Ueland  
Ben Schofield  
Matthias Vallentin  
Valeriy Vorotyntsev  
Timothy Noel  
Gary Lipsky

Michael Barbine

Et des ingénieurs travaillant chez GreyNoise, Hunt, Google, ExtraHop, F5, Driftnet et d'autres.

Contactez John Althouse à [email protected] pour les licences et les questions.

<sub>JA4 et JA4+ sont des marques déposées de FoxIO, Inc.  
Copyright (c) 2026, FoxIO</sup>

Catégories