Decoder : Déchiffrer les paquets entrants

Document created by RSA Information Design and Development Employee on Apr 28, 2019
Version 1Show Document
  • View in full screen mode
 

À partir de la version NetWitness Platform 11.0, les administrateurs peuvent configurer un Network Decoder pour déchiffrer les paquets entrants à l’aide de la commande sslKeys. Les analyseurs activés pourront voir la charge utile du paquet non chiffré et créer des métadonnées en conséquence. Si le Decoder n’est pas configuré pour déchiffrer les paquets entrants, la plupart des analyseurs activés ne verront que du garbage chiffré et ne pourront pas créer de métadonnées significatives.

Remarque : Si FIPS est activé, la liste des chiffrements permettant le déchiffrement se limite à ceux approuvés par FIPS.

La commande sslKeys permet de télécharger des clés premaster ou des clés privées sur le Decoder, afin que la capture des paquets chiffrés qui correspondent aux clés puissent être déchiffrés avant l’analyse. Les administrateurs peuvent configurer le Decoder en saisissant la commande sslKeys à l’aide de l’interface de ligne de commande NwConsole ou de l’interface RESTful Decoder.

This is an example of the command line interface.

Le formulaire de l'interface RESTful à l’emplacement : /decoder/sslkeys permet de télécharger une clé privée unique au format d’encodage PEM, un fichier unique contenant plusieurs clés privées concaténées, ou un fichier unique contenant plusieurs clés premaster.

This is an example of the RESTful interface form.

Bien que les paquets soient déchiffrés durant la phase d’analyse, seuls les paquets chiffrés sont écrits sur le disque. La clé premaster correspondante, utilisée pour le déchiffrement, est écrite sur la clé méta tls.premaster, que les analystes peuvent ensuite utiliser à la demande pour afficher les paquets non chiffrés.

Vous trouverez ci-dessous des détails permettant aux administrateurs de configurer le déchiffrement des paquets entrants et aux analystes de visualiser les paquets non chiffrés à la demande.

Considérations relatives aux performances

Le déchiffrement des paquets en temps réel requiert un travail supplémentaire en phase d’analyse. Avant d’implémenter cette fonction, planifiez soigneusement pour vous assurer que la bande passante de trafic entrant n’excède pas la puissance de calcul disponible. Vous aurez peut-être besoin de plus de Decoders pour déchiffrer le trafic que si vous n’utilisez pas le déchiffrement.

Les paquets capturés sur un Decoder ont généralement un délai d’expiration de 60 secondes en phase d’assemblage avant d’être envoyés à l’étape d’analyse. Si le Decoder est sous pression au niveau de la mémoire en raison d’une utilisation très élevée de la bande passante, il se peut que la durée de vie des paquets dans l’assembleur soit raccourcie. Pour résoudre cette situation, vous pouvez configurer une valeur plus longue du délai d’expiration et augmenter la quantité de mémoire disponible pour conserver les paquets dans l’assemblage. En outre, pour effectuer le déchiffrement des paquets, le Decoder doit recevoir la clé de déchiffrement avant l’étape d’analyse.

Remarque : Actuellement, seuls les protocoles TLS 1.2 et les protocoles antérieurs peuvent être déchiffrés.

Lorsqu’aucun feed n’est chargé, que les analyseurs suivants sont activés et que 50 % des sessions sont déchiffrées, un Decoder peut traiter le trafic à 3 Gbit/s.

                                                                                                                                                                                           
Nom de l'analyseurDescription
SYSTEMDétails de la session
NETWORKCouche réseau
ALERTSAlertes
GeoIPDonnées géographiques basées sur ip.src et ip.dst
GeoIP2Données géographiques par défaut basées sur les clés META IPv4 (ip.src, ip.dst) et IPv6 (ipv6.src, ipv6.dst)
HTTPHyper Text Transport Protocol (HTTP)
HTTP_LuaHyper Text Transport Protocol (HTTP) Lua
FTPFile Transfer Protocol (FTP)
TELNET Protocole TELNET

SMTP

Simple Mail Transport Protocol (SMTP)

POP3Post Office Protocol (POP3)

NNTP

Network News Transport Protocol (NNTP)

DNSDomain Name Service (DNS)

HTTPS

Protocole Secure Socket Layer (SSL)

MAILFormat d’e-mail standard (RFC822)

VCARD

Extrait les informations de nom complet et d’e-mail de VCARD

PGPIdentifie les blocs PGP au sein du trafic réseau

SMIME

Identifie les blocs SMIME au sein du trafic réseau

SSHSecure Shell (SSH)

TFTP

TFTP (Trivial File Transfer Protocol)

DHCPDynamic Host Configuration Protocol (DHCP et BOOTP)

NETBIOS

Extrait les informations de nom d’ordinateur NETBIOS.

SNMPSimple Network Management Protocol (SNMP)

NFS

Protocole Network File System (NFS)

RIPRouting Information Protocol (RIP).
TDSProtocole de base de données MSSQL et Sybase (TDS)

TNS

Protocole de base de données Oracle (TNS)

IRCProtocole Internet Relay Chat (IRC)

RTP

Real Time Protocol (RTP) pour l’audio et la vidéo

SIPSession Initiation Protocol (SIP)

H323

Protocole de téléconférence H.323

SCCPProtocole Cisco Skinny Client Control

GTalk

Google Talk (GTalk)

VlanGreVlan ID et adresses de tunnel GRE/EtherIP

BITTORRENT

Protocole de partage de fichiers BitTorrent

FIXProtocole Financial Information eXchange

GNUTELLA

Protocole de partage de fichiers Gnutella

IMAPInternet Message Access Protocol

MSRPC

Protocole Microsoft Remote Procedure Call

RDPRemote Desktop Protocol

SHELL

Identification de Shell de commande

TLSv1TLSv1

SearchEngines

Analyseur qui extrait des termes de recherche

FeedParserAnalyseur de feed externe

Clés de chiffrement

La commande sslKeys accepte deux types de clés de chiffrement :

  • Clé premaster : clé symétrique utilisée dans le flux de charge utile TLS pour le chiffrement et le déchiffrement.
  • Clé privée : clé privée asymétrique utilisée lors de la négociation TLS qui chiffre la clé premaster.

Clé premaster

La clé premaster est générée de manière aléatoire et éphémère pour la durée de vie d’une session TLS spécifique. En règle générale, il n’existe pas de manière idéale pour transférer les clés premaster vers un Decoder à temps pour l’étape d’analyse. Toutefois, Chrome et Firefox peuvent tous deux écrire les clés premaster qu’ils génèrent dans un fichier. Cela est utile à des fins de test. Pour configurer votre navigateur à cet effet, créez une variable d’environnement appelée SSLKEYLOGFILE et attribuez-lui le chemin d’accès du fichier dans lequel les clés seront écrites. Le Decoder accepte le fichier exactement tel qu’il a été écrit et utilise toutes les clés de déchiffrement dans le fichier pour tout le trafic chiffré qu'il capture.

Exemple de script NwConsole qui télécharge le fichier sur un Decoder :

login <decoder>:50004 <username> <password>

send /decoder sslKeys --file-data=SSLKeys.txt

Exemple d’utilisation d’une commande curl (avec le port RESTful) pour télécharger le fichier vers un Decoder :

curl -u "<username>:<password>" -H "Content-Type: application/octet-stream" --data-binary @"/path/SSLKeys.txt" -X POST "http://<hostname>:50104/decoder?msg=sslKeys"

Lorsque les clés symétriques sont téléchargées, elles sont immédiatement utilisées pour n’importe quel déchiffrement nécessaire. Les clés symétriques sont stockées dans la mémoire et il existe une limite quant au nombre de clés pouvant être stockées à un moment donné. Lorsque de nouvelles clés sont stockées, les plus anciennes expirent. Vous pouvez également ajouter des clés premaster en transmettant uniquement les paramètres random et premaster vers sslKeys.

Clés privées ou fichiers PEM

Les clés privées sont généralement stockées dans des fichiers au format PEM et sont les clés asymétriques générées par les services qui acceptent le trafic TLS. Ces clés sont utilisées lors de la négociation TLS pour chiffrer la clé symétrique premaster qui sera utilisée pour le reste du chiffrement de la charge utile.

Par exemple, si vous disposez d’un serveur Web sur lequel vous souhaitez une visibilité, vous devez télécharger la clé privée qu’il utilise pour chiffrer le trafic. Il vous suffit d’effectuer cette procédure une seule fois car elle est stockée de manière permanente (ou jusqu’à ce qu’elle soit supprimée par la commande de suppression). Les clés privées sont automatiquement chiffrés avant leur stockage afin de les protéger. Après le téléchargement, vous devez émettre une commande destinée à recharger l’analyseur afin que la clé nouvellement installée devienne visible pour l’analyseur HTTPS. Ainsi, toutes les négociations TLS qui utilisent cette clé privée pourront être déchiffrées par le Decoder.

Remarque : Toutes les suites de chiffrement n’utilisent pas de clé privée « connue » (par exemple, Diffie Hellman éphémère). Le trafic ainsi chiffré ne peut pas être déchiffré à moins qu’une clé premaster soit téléchargée sur le Decoder avant l’analyse de la session.

Voici quelques exemples de commandes qui téléchargent un fichier PEM à utiliser pour le déchiffrement.

À l’aide de NwConsole :

send /decoder sslKeys pemFilename=MyKey.pem --file-data=/path/MyKey.pem

À l’aide de l’interface RESTful (vous devez fournir le paramètre pemFilename dans l’URL) :

curl -u "<username>:<password>" -H "Content-Type: application/octet-stream" --data-binary @"/path/MyKey.pem" -X POST "http://<hostname>:50104/decoder?msg=sslKeys&pemFilename=MyKey.pem"

Télécharger plusieurs clés premaster et clés privées

Vous pouvez utiliser le formulaire de l’interface RESTful pour faciliter le chargement de plusieurs clés (premaster et privées) en même temps.

  1. Ouvrez l’API RESTful dans votre navigateur et accédez à ce chemin d’accès sur le Decoder que vous souhaitez configurer : /decoder/sslkeys.
    This is an example of the RESTful interface form.
  2. En regard de Télécharger le fichier 1, cliquez sur Choisir le fichier et recherchez le fichier de clé premaster ou le fichier PEM que vous souhaitez télécharger sur votre système de fichiers local.
  3. (Facultatif) Répétez cette étape pour Télécharger le fichier 2 et Télécharger le fichier 3.
    This is an example of the RESTful interface form with additional uploads.
  4. Cliquez sur Télécharger.
    Les fichiers sont téléchargés vers Decoder et les résultats s’affichent dans le formulaire.
    This is an example of the RESTful interface form with results.

Paramètres pour la gestion des clés

La commande sslKeys dispose de plusieurs paramètres pour gérer les clés premaster et privées. Voici la liste complète des paramètres :

                                   
ParamètreDescription
clear Supprime toutes les clés premaster de la mémoire. Ne supprime aucun fichier PEM installé sur le système.
maxKeys Modifie le nombre maximal de clés premaster qui sont stockées dans la mémoire.
listPems Renvoie une liste de tous les fichiers PEM de clés privées installées.
deletePem Supprime le fichier PEM nommé à partir du système de fichiers. Vous pouvez passer ce paramètre plusieurs fois pour supprimer plusieurs fichiers.
random Valeur de hachage aléatoire permettant d’identifier la clé premaster.
premaster Clé premaster qui est installée pour le paramètre random précédent. Ils doivent s’afficher par paires et random doit être le premier.

Valeurs renvoyées

La plupart des commandes sslKeys renvoient des paires nom/valeur de statistiques sur les clés premaster en mémoire. Les statistiques sont répertoriées dans le tableau suivant.

                           
NomDescription
added Nombre de clés premaster qui viennent d’être ajoutées pendant cette commande.
total Nombre total de clés premaster chargées en mémoire.
agedOut Nombre total de clés premaster qui ont été supprimées pendant cette commande ; il ne s’agit pas d’une statistique de durée de vie.
maxKeys Nombre maximal actuel de clés premaster autorisées

Affichage du trafic non chiffré

Si des paquets sont déchiffrés durant la phase d’analyse, des paquets chiffrés sont écrits sur le disque et la clé premaster correspondante, utilisée pour le déchiffrement, est écrite sur la clé méta tls.premaster. Les analystes peuvent afficher les paquets non chiffrés à l’aide de la clé méta tls.premaster.

Le service /sdk/content RESTful est une API de Decoder que vous pouvez utiliser pour voir les paquets déchiffrés. Vous devez connaître l’identifiant de session des paquets chiffrés et le paramètre flags masqué pour la valeur 128 (ou 0 x 80 au format hexadécimal). Avec votre navigateur, accédez à l’interface RESTful du Decoder et saisissez la commande suivante, en remplaçant l’identifiant de session réel pour <id> :

http://<decoder>:50104/sdk/content?session=<id>&flags=128&render=text

Le Decoder renvoie à une simple page Web affichant les paquets une fois qu’ils sont déchiffrés.

Si vous souhaitez voir à quoi ressemblent les paquets chiffrés, saisissez l’une des commandes suivantes, en remplaçant l’identifiant de session pour <id> :

http://<decoder>:50104/sdk/content&session=<id>&render=text

http://<decoder>:50104/sdk/content&session=<id>&flags&render=text

Pour plus d’informations sur le service /sdk/content, reportez‑vous à la page du manuel relative au contenu /sdk/.

Suites de chiffrement prises en charge

Le tableau suivant répertorie les suites de chiffrement prises en charge à l'aide de clés privées.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
Nom de la suite de chiffrement (RFC)Nom (OpenSSL)Suites de chiffrementVersion de TLS KeyExch.FIPSClé privée
TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384ECDHE-RSA-AES256-GCM-SHA384[0xc030]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384ECDHE-ECDSA-AES256-GCM-SHA384[0xc02c]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384ECDHE-RSA-AES256-SHA384[0xc028]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384ECDHE-ECDSA-AES256-SHA384[0xc024]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHAECDHE-RSA-AES256-SHA[0xc014]SSLv3Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHAECDHE-ECDSA-AES256-SHA[0xc00a]SSLv3Kx=ECDHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_256_GCM_SHA384DHE-DSS-AES256-GCM-SHA384[0xa3]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384DHE-RSA-AES256-GCM-SHA384[0x9f]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256DHE-RSA-AES256-SHA256[0x6b]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_256_CBC_SHA256DHE-DSS-AES256-SHA256[0x6a]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_256_CBC_SHADHE-RSA-AES256-SHA[0x39]SSLv3Kx=DHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_256_CBC_SHADHE-DSS-AES256-SHA[0x38]SSLv3Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHADHE-RSA-CAMELLIA256-SHA[0x88]SSLv3Kx=DHNon conformeNon pris en charge
TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHADHE-DSS-CAMELLIA256-SHA[0x87]SSLv3Kx=DHNon conformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384ECDH-RSA-AES256-GCM-SHA384[0xc032]SSLv3Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384ECDH-ECDSA-AES256-GCM-SHA384[0xc02e]TLSv1.2Kx=ECDH/ECDSAConformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384ECDH-RSA-AES256-SHA384[0xc02a]TLSv1.2Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384ECDH-ECDSA-AES256-SHA384[0xc026]TLSv1.2Kx=ECDH/ECDSAConformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_256_CBC_SHAECDH-RSA-AES256-SHA[0xc00f]SSLv3Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHAECDH-ECDSA-AES256-SHA[0xc005]SSLv3Kx=ECDH/ECDSAConformeNon pris en charge
TLS_RSA_WITH_AES_256_GCM_SHA384AES256-GCM-SHA384[0x9d]TLSv1.2Kx=RSAConformePris en charge
TLS_RSA_WITH_AES_256_CBC_SHA256AES256-SHA256[0x3d]TLSv1.2Kx=RSAConformePris en charge
TLS_RSA_WITH_AES_256_CBC_SHAAES256-SHA[0x35]SSLv3Kx=RSAConformePris en charge
TLS_RSA_WITH_CAMELLIA_256_CBC_SHACAMELLIA256-SHA[0x84]SSLv3Kx=RSANon conformePris en charge
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHAECDHE-RSA-DES-CBC3-SHA[0xc012]SSLv3Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHAECDHE-ECDSA-DES-CBC3-SHA[0xc008]SSLv3Kx=ECDHConformeNon pris en charge
TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHAEDH-RSA-DES-CBC3-SHA[0x16]SSLv3Kx=DHConformeNon pris en charge
TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHAEDH-DSS-DES-CBC3-SHA[0x13]SSLv3Kx=DHConformeNon pris en charge
TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHAECDH-RSA-DES-CBC3-SHA[0xc00d]SSLv3Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHAECDH-ECDSA-DES-CBC3-SHA[0xc003]SSLv3Kx=ECDH/ECDSAConformeNon pris en charge
TLS_RSA_WITH_3DES_EDE_CBC_SHADES-CBC3-SHA[0x0a]SSLv3Kx=RSAConformePris en charge
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256ECDHE-RSA-AES128-GCM-SHA256[0xc02f]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256ECDHE-ECDSA-AES128-GCM-SHA256[0xc02b]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256ECDHE-RSA-AES128-SHA256[0xc027]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256ECDHE-ECDSA-AES128-SHA256[0xc023]TLSv1.2Kx=ECDHConformeNon pris en charge
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHAECDHE-RSA-AES128-SHA[0xc013]SSLv3Kx=ECDHConformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHAECDHE-ECDSA-AES128-SHA[0xc009]SSLv3Kx=ECDHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_128_GCM_SHA256DHE-DSS-AES128-GCM-SHA256[0xa2]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256DHE-RSA-AES128-GCM-SHA256[0x9e]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256DHE-RSA-AES128-SHA256[0x67]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_128_CBC_SHA256DHE-DSS-AES128-SHA256[0x40]TLSv1.2Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_AES_128_CBC_SHADHE-RSA-AES128-SHA[0x33]SSLv3Kx=DHConformeNon pris en charge
TLS_DHE_DSS_WITH_AES_128_CBC_SHADHE-DSS-AES128-SHA[0x32]SSLv3Kx=DHConformeNon pris en charge
TLS_DHE_RSA_WITH_SEED_CBC_SHADHE-RSA-SEED-SHA[0x9a]SSLv3Kx=DHNon conformeNon pris en charge
TLS_DHE_DSS_WITH_SEED_CBC_SHADHE-DSS-SEED-SHA[0x99]SSLv3Kx=DHNon conformeNon pris en charge
TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHADHE-RSA-CAMELLIA128-SHA[0x45]SSLv3Kx=DHNon conformeNon pris en charge
TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHADHE-DSS-CAMELLIA128-SHA[0x44]SSLv3Kx=DHNon conformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256ECDH-RSA-AES128-GCM-SHA256[0xc031]TLSv1.2Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256ECDH-ECDSA-AES128-GCM-SHA256[0xc02d]TLSv1.2Kx=ECDH/ECDSAConformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256ECDH-RSA-AES128-SHA256[0xc029]TLSv1.2Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256ECDH-ECDSA-AES128-SHA256[0xc025]TLSv1.2Kx=ECDH/ECDSAConformeNon pris en charge
TLS_ECDH_RSA_WITH_AES_128_CBC_SHAECDH-RSA-AES128-SHA[0xc00e]SSLv3Kx=ECDH/RSAConformeNon pris en charge
TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHAECDH-ECDSA-AES128-SHA[0xc004]SSLv3Kx=ECDH/ECDSAConformeNon pris en charge
TLS_RSA_WITH_AES_128_GCM_SHA256AES128-GCM-SHA256[0x9c]TLSv1.2Kx=RSAConformePris en charge
TLS_RSA_WITH_AES_128_CBC_SHA256AES128-SHA256[0x3c]TLSv1.2Kx=RSAConformePris en charge
TLS_RSA_WITH_AES_128_CBC_SHAAES128-SHA[0x2f]SSLv3Kx=RSAConformePris en charge
TLS_RSA_WITH_SEED_CBC_SHASEED-SHA[0x96]SSLv3Kx=RSANon conformePris en charge
TLS_RSA_WITH_CAMELLIA_128_CBC_SHACAMELLIA128-SHA[0x41]SSLv3Kx=RSANon conformePris en charge
TLS_RSA_WITH_IDEA_CBC_SHAIDEA-CBC-SHA[0x07]SSLv3Kx=RSANon conformePris en charge
TLS_ECDHE_RSA_WITH_RC4_128_SHAECDHE-RSA-RC4-SHA[0xc011]SSLv3Kx=ECDHNon conformeNon pris en charge
TLS_ECDHE_ECDSA_WITH_RC4_128_SHAECDHE-ECDSA-RC4-SHA[0xc007]SSLv3Kx=ECDHNon conformeNon pris en charge
TLS_ECDH_RSA_WITH_RC4_128_SHAECDH-RSA-RC4-SHA[0xc00c]SSLv3Kx=ECDH/RSANon conformeNon pris en charge
TLS_ECDH_ECDSA_WITH_RC4_128_SHAECDH-ECDSA-RC4-SHA[0xc002]SSLv3Kx=ECDH/ECDSANon conformeNon pris en charge
TLS_RSA_WITH_RC4_128_SHARC4-SHA[0x05]SSLv3Kx=RSANon conformePris en charge
TLS_DHE_RSA_WITH_DES_CBC_SHAEDH-RSA-DES-CBC-SHA[0x15]SSLv3Kx=RSANon conformeNon pris en charge
TLS_DHE_DSS_WITH_DES_CBC_SHAEDH-DSS-DES-CBC-SHA[0x12]SSLv3Kx=DSSNon conformeNon pris en charge
TLS_RSA_WITH_DES_CBC_SHADES-CBC-SHA[0x09]SSLv3Kx=RSANon conformePris en charge
TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHAEXP-EDH-RSA-DES-CBC-SHA[0x14]SSLv3Kx=DSSNon conformeNon pris en charge
TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHAEXP-EDH-DSS-DES-CBC-SHA[0x11]SSLv3Kx=DSSNon conformeNon pris en charge
TLS_RSA_EXPORT_WITH_DES40_CBC_SHAEXP-DES-CBC-SHA[0x08]SSLv3Kx=DESNon conformePris en charge

Hachage du certificat TLS

Le Network Decoder peut produire des hachages de certificats qui sont visibles dans le flux de paquets. Ces hachages sont la valeur SHA-1 de tout certificat codé DER rencontré lors d'une négociation TLS. Les hachages produits peuvent être utilisés pour comparer le trafic réseau avec les hachages des listes noires SSL publiques, comme celle de sslbl.abuse.ch.

La fonctionnalité de hachage de certificat TLS est désactivée par défaut. Elle peut être activée en ajoutant l'option du parser :

HTTPS="cert.sha1=true"

à la configuration /decoder/parsers/config/parsers.options d’un Network Decoder.

Lorsque cette option est activée, le SHA-1 est stocké sous la forme d'une valeur de texte dans la méta-clé :

cert.checksum

You are here
Table of Contents > Procédures supplémentaires de Decoder et Log Decoder > Déchiffrer les paquets entrants

Attachments

    Outcomes