cloudflare/mitmengineUn outil de détection MITM (monstre au milieu). Utilisé pour construire MALCOLM :
L'objectif de ce projet est de permettre une détection précise des interceptions HTTPS et un robuste empreinte digitale TLS. Ce projet se base sur The Security Impact of HTTPS Interception, et a débuté comme un portage en Go de leurs scripts de traitement et empreintes.
Plus de contexte sur MITMEngine est disponible dans ce billet de blog Cloudflare. Liens rapides :
wireshark -v pour vérifier)La documentation détaillée se trouve avec le code (copiez d'abord le package dans $(GOPATH)/src/github.com/cloudflare/mitmengine).
godoc -http=:6060
http://localhost:6060/pkg/github.com/cloudflare/mitmengine
Dans ce projet, les empreintes correspondent à des instanciations concrètes d'un objet, tandis que les signatures peuvent représenter plusieurs objets. Nous utilisons cette convention car une empreinte est généralement une propriété inhérente d'un objet, alors qu'une signature peut être choisie. De la même manière, une requête client réelle vue par un serveur aurait une empreinte, tandis que le logiciel générant la requête peut choisir sa propre signature (par exemple, en choisissant les suites de chiffrement qu'il supporte).
Une empreinte de requête client est dérivée d'une requête client vers un serveur, et contient à la fois des caractéristiques TLS et HTTP. Une signature de requête client représente toutes les empreintes possibles qu'un logiciel peut générer. L'objectif est de rendre chaque signature suffisamment spécifique pour identifier de manière unique un logiciel.
Une signature User Agent représente un ensemble d'User Agents générés par un navigateur. Une signature User Agent pour un navigateur autorise une plage de versions de navigateur, et permet de spécifier le nom du système d'exploitation, la plateforme du système d'exploitation, la plage de versions du système d'exploitation et le type d'appareil pour créer des signatures plus fines.
Une signature de navigateur contient à la fois une signature User Agent et une signature de requête client. Cela permet à une signature de représenter toutes les empreintes possibles générées par Chrome 31-38 sur Windows 10, par exemple.
Une signature MITM contient une signature de requête client ainsi que des détails supplémentaires sur le logiciel MITM, y compris une note de sécurité qui peut être affectée par des facteurs externes à la requête client, comme le fait que le logiciel valide ou non les certificats.
Nous considérons qu'une connexion HTTPS est interceptée lorsqu'il y a une discordance entre la signature de requête client attendue correspondant au navigateur identifié par le User Agent, et l'empreinte réelle de la requête client.
Si une signature est imprécise ou obsolète pour un logiciel client donné, il est possible que la signature signale faussement une connexion comme étant interceptée.
Si un proxy imite étroitement la requête du client, nous pourrions ne pas détecter de discordance. Si les signatures des navigateurs sont trop larges, nous ne parviendrons pas non plus à détecter l'interception.
Les empreintes de référence des navigateurs et des logiciels MITM utilisées dans MALCOLM se trouvent dans reference_fingerprints/mitmengine/.
Cet ensemble d'empreintes est une combinaison de ce qui est extrait des pcaps TLS Client Hello dans reference_fingerprints/pcaps/, ainsi que des 500 meilleurs paires User Agent + TLS Client Hello observées sur le réseau de Cloudflare et étiquetées avec un indice de fiabilité élevé (c'est-à-dire du trafic correspondant à une activité humaine et de robots amicaux).
Idéalement, nous n'aurions pas à nous fier aux empreintes de référence échantillonnées sur le réseau de Cloudflare ; nous aurions plutôt un ensemble complet de pcaps pour construire notre ensemble de TLS Client Hello de référence. Vous souhaitez nous aider à enrichir notre jeu de données ? Voyez comment vous pouvez contribuer !
Tout d'abord, un utilisateur doit créer une structure mitmengine.Config à passer à mitmengine.NewProcessor. Une structure mitmengine.Config peut spécifier les noms de fichiers contenant les empreintes de navigateurs, les empreintes MITM et les en-têtes MITM. Alternativement, elle peut également spécifier un fichier de configuration pour lire les fichiers mentionnés précédemment depuis toute autre source ; actuellement, MITMEngine supporte la lecture de ces fichiers depuis des bases de données compatibles avec le client Amazon S3 (y compris Amazon S3 et Ceph). Des lecteurs de fichiers supplémentaires pour les bases de données (que nous appelons « chargeurs ») peuvent être définis dans le package loaders, et tant que les nouveaux chargeurs implémentent l'interface Loader, ils devraient fonctionner avec le reste de MITMEngine sans modification.
Le point d'entrée prévu pour le package MITMEngine est la fonction Processor.Check, qui prend un User Agent et une empreinte de requête client, et retourne un rapport de détection mitm. Des fonctions API supplémentaires seront ajoutées à l'avenir pour permettre, par exemple, d'ajouter de nouvelles signatures à un processus en cours.
Un exemple d'utilisation de l'API est ci-dessous. Une application plus complète est disponible dans cmd/demo/main.go, et peut être construite en exécutant make bin/demo.
rawUa := "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36"
requestFingerprintString := "303:dada,1301,1302,1303,c02b,c02f,c02c,c030,cca9,cca8,c013,c014,9c,9d,2f,35,a:aaaa,0,17,ff01,a,b,23,10,5,d,12,33,2d,2b,1b,dada,15:9a9a,1d,17,18:0::"
uaFingerprintString := "1:72.0.3626:2:3:10.14.3:1:"
requestFingerprint, _ := fp.NewRequestFingerprint(requestFingerprintString)
uaFingerprint, _ := fp.NewUAFingerprint(uaFingerprintString)
report := mitmProcessor.Check(uaFingerprint, rawUa, requestFingerprint)
Le TLS requestFingerprintString a le format suivant :
<tls_version>:<cipher_suites>:<extension_names>:<curves>:<ec_point_fmts>:<http_headers>:<quirks>
Le uaFingerprint a le format suivant :
# <browser_name>:<browser_version>:<os_platform>:<os_name>:<os_version>:<device_type>:<quirks>
Un exemple de la façon d'analyser les User Agents dans le format pour uaFingerprint se trouve dans le fichier cmd/demo/main.go.
Pour utiliser MITMEngine, n'oubliez pas d'importer ses dépendances. Vous voudrez probablement exécuter une logique de vendoring ou gomod avant d'exécuter les tests sur MITMEngine.
Pour tester, exécutez make test et pour voir la couverture de code, exécutez make cover.
Étant donné que les empreintes de navigateurs et de mitm deviennent rapidement obsolètes, nous cherchons activement à mettre à jour le dépôt d'empreintes avec de nouveaux échantillons.
En contribuant un échantillon d'empreinte (l'« Échantillon »), vous (en votre nom ou au nom de l'organisation que vous représentez ou par laquelle vous êtes parrainé(e) (le cas échéant)) accordez à Cloudflare, Inc. et à ses filiales et sociétés affiliées une licence perpétuelle, irrévocable, non exclusive, sans redevance, mondiale et sous tous les droits de propriété intellectuelle sur l'Échantillon, pour : (1) copier, publier, afficher et distribuer l'Échantillon ; et (2) préparer des œuvres dérivées basées sur ou faisant partie de l'Échantillon.
Pour contribuer des échantillons d'empreintes, veuillez suivre ces étapes :
(testé sur macOS Mojave 10.14.3)
Créez une paire de certificat et clé RSA serveur :
openssl req -new -x509 -sha256 -out server.crt -nodes -keyout server.pem -subj /CN=localhost
Démarrez le serveur sur le port 4433 :
openssl s_server -www -cipher AES256-SHA -key server.pem -cert server.crt
Démarrez la capture TShark pour déchiffrer les en-têtes HTTP (TShark >= 3.0.0) :
tshark -i loopback -o tls.keys_list:"127.0.0.1,4433,http,server.pem" -Tjson -e http.request.line -Y http > header.json
Démarrez la capture TShark du TLS Client Hello :
tshark -i loopback -f "tcp port 4433" -w handshake.pcap
Visitez https://localhost:4433 depuis le client TLS que vous souhaitez empreinter. Par exemple,
echo -e "GET /test HTTP/1.1\r\nHost:example.com\r\n\r\n" | openssl s_client -connect localhost:4433
Générez un échantillon d'empreinte (header.json, handshake.pcap) comme décrit ci-dessus, et placez-le dans le répertoire reference_fingerprints/pcaps/<desc>, où <desc> est un nom unique et descriptif.
Ajoutez une ligne au fichier reference_fingerprints/fingerprint_metadata.jsonl avec les champs ci-dessous. Les options reconnues pour les champs os, device, platform et browser sont celles définies dans le package uasurfer. Les options reconnues pour mitm_fingerprint.type sont listées ci-dessous. Voir reference_fingerprints/fingerprint_metadata.jsonl pour des exemples ; les champs inconnus peuvent être laissés vides ou omis.
{ "desc": "<nom unique et descriptif pour l'échantillon>", "comment": "<information supplémentaire sur l'échantillon>", "handshake_pcap": "", "header_json": "<(optionnel) chemin vers le fichier contenant la requête HTTP client", "ua_fingerprint": {"raw_ua": "<chaîne User Agent brute>", "os": "<WindowsPhone|Windows|MacOSX|iOS|Android|...>", "os_version": "..", "device": "<Windows|Mac|Linux|...>", "platform": "<Computer|Tablet|Phone|...>", "browser": "<Chrome|IE|Safari|Firefox|...>", "browser_version": ".."}, "mitm_fingerprint": { "name": "", "type": "<Antivirus|FakeBrowser|Malware|Parental|Proxy>" }}
Les autres PR et demandes de fonctionnalités sont les bienvenues !
mergeDB (dans cmd/mergedb) est un utilitaire permettant de fusionner des empreintes TLS ClientHello similaires entre plusieurs versions proches de navigateurs ou de logiciels MITM.
Utilisez mergeDB pour consolider de grandes listes d'empreintes User Agent / Client Hello :
go run cmd/mergedb/main.go
Par défaut, mergeDB s'exécutera sur les empreintes dans le répertoire reference_fingerprints/mitmengine.
Soumettez une pull request avec les modifications ci-dessus.