Decoder: Descifrar los paquetes entrantes

Document created by RSA Information Design and Development on Apr 23, 2018Last modified by RSA Information Design and Development on Apr 28, 2019
Version 2Show Document
  • View in full screen mode
 

A partir de NetWitness Platform 11.0, los administradores pueden configurar un Network Decoder para descifrar paquetes entrantes mediante el comando sslKeys. Los analizadores habilitados verán la carga útil de los paquetes sin cifrar y crearán metadatos según corresponda. Si el Decoder no está configurado para descifrar los paquetes entrantes, la mayoría de los analizadores habilitados verán solo elementos no utilizados cifrados y no podrán crear metadatos significativos.

Nota: Si FIPS está habilitado, la lista de cifrados para descifrado está restringida solo a aquellos que aprueba FIPS.

El comando sslKeys proporciona una manera de cargar las claves premaster o privadas en el Decoder, para que los paquetes cifrados capturados que coincidan con las claves puedan descifrarse antes de su análisis. Los administradores configuran el Decoder mediante el ingreso del comando sslKeys con la interfaz de la línea de comandos de NwConsole o la interfaz RESTful del Decoder.

This is an example of the command line interface.

El formulario de la interfaz RESTful en la ruta: /decoder/sslkeys permite cargar una única clave privada con codificación PEM, un solo archivo que contiene varias claves privadas concatenadas o un único archivo de varias claves de premaster.

This is an example of the RESTful interface form.

A pesar de que los paquetes se descifran durante la etapa de análisis, solo los paquetes cifrados se escriben en el disco. La clave de premaster coincidente que se usa para descifrar se escribe en la clave de metadatos tls.premaster, que los analistas pueden usar para ver posteriormente los paquetes sin cifrar según demanda.

A continuación, se proporcionan detalles para que los administradores configuren el descifrado de paquetes entrantes y para que los analistas vean los paquetes sin cifrar según demanda.

Consideraciones de rendimiento

El descifrado de paquetes en tiempo real requiere trabajo adicional en la etapa de análisis. Antes de implementar esta función, planee cuidadosamente a fin de garantizar que el ancho de banda de tráfico entrante no supere la potencia de procesamiento disponible. Puede que necesite más Decoders para descifrar el tráfico en relación con lo que necesitaría si no descifrara.

Los paquetes capturados en un Decoder normalmente tienen un tiempo de espera de aproximadamente 60 segundos en la etapa de ensamblaje antes de que se envíen a la etapa de análisis. Si el Decoder está bajo presión de memoria debido al ancho de banda muy alto, puede disminuir el ciclo de vida de los paquetes en el ensamblador. Para solucionar esta situación, puede configurar un valor de tiempo de espera mayor y aumentar la cantidad de memoria disponible para almacenar los paquetes en el ensamblaje. Además, a fin de llevar a cabo el descifrado de los paquetes, el Decoder debe recibir la clave de descifrado antes de la etapa de análisis.

Nota: Actualmente, se pueden descifrar solo los protocolos TLS 1.2 y anteriores

Sin tener ningún feed cargado, los siguientes analizadores habilitados y un 50 % de las sesiones que se descifran, un Decoder puede procesar el tráfico a 3 GB/s.

                                                                                                                                                                                           
Nombre del analizadorDescripción
SYSTEMDetalles de la sesión
NETWORKCapa de red
ALERTASAlertas
GeoIPDatos geográficos en función de ip.src e ip.dst
GeoIP2Datos geográficos de manera predeterminada basados en claves de metadatos IPv4 (ip.src y ip.dst) e IPv6 (ipv6.src y ipv6.dst)
HTTPProtocolo de transporte de hipertexto (HTTP)
HTTP_LuaProtocolo de transporte de hipertexto (HTTP) Lua
FTPProtocolo de transferencia de archivos (FTP)
TELNET Protocolo TELNET

SMTP

Protocolo simple de transferencia de correo (SMTP)

POP3Protocolo de oficina de correos (POP3)

NNTP

Protocolo de transporte de noticias de red (NNTP)

DNSServicio de nombres de dominio (DNS)

HTTPS

Protocolo de capa de conexión segura (SSL)

MAILFormato de correo electrónico estándar (RFC822)

VCARD

Extrae la información de correo electrónico y el nombre completo de VCARD

PGPIdentifica los bloques PGP dentro del tráfico de red

SMIME

Identifica los bloques SMIME dentro del tráfico de red

SSHProtocolo SSH

TFTP

Protocolo de transferencia de archivos trivial (TFTP)

DHCPProtocolo de configuración de host dinámico (DHCP y BOOTP)

NETBIOS

Extrae información de nombre de computadora de NETBIOS.

SNMPProtocolo de administración de redes (SNMP)

NFS

Protocolo de Network File System (NFS)

RIPProtocolo de información de enrutamiento (RIP).
TDSProtocolo de base de datos MSSQL y Sybase (TDS)

TNS

Protocolo de base de datos de Oracle (TNS)

IRCProtocolo de Internet Relay Chat (IRC)

RTP

Protocolo de tiempo real (RTP) de audio/video

SIPProtocolo de inicio de sesión (SIP)

H323

Protocolo de teleconferencia H.323

SCCPProtocolo de control de cliente ligero de Cisco

GTalk

Google Talk (GTalk)

VlanGreID de VLAN y direcciones de túnel GRE/EtherIP

BITTORRENT

Protocolo de uso compartido de archivos de BitTorrent

FIXProtocolo de intercambio de información financiera

GNUTELLA

Protocolo de uso compartido de archivos de Gnutella

IMAPProtocolo de acceso a mensajes de Internet

MSRPC

Protocolo de llamada a procedimiento remoto de Microsoft

RDPProtocolo de escritorio remoto

SHELL

Identificación del shell de comandos

TLSv1TLSv1

SearchEngines

Un analizador que extrae términos de búsqueda

FeedParserAnalizador de alimentación externa

Claves de cifrado

El comando sslKeys acepta dos tipos de claves de cifrado:

  • Clave de premaster: la clave simétrica que se usa en el flujo de la carga útil TLS para el cifrado y descifrado.
  • Clave privada: la clave privada asimétrica que se usa durante el protocolo de enlace de TLS que cifra la premaster.

Clave de premaster

La clave de premaster se genera aleatoriamente y es efímera durante la vida útil de una sesión específica de TLS. Por lo general, no hay una buena forma de obtener las claves de premaster para un Decoder en el tiempo para la etapa de análisis. Sin embargo, Chrome y Firefox pueden escribir en un archivo las claves de premaster que se generan. Esto es útil para fines de prueba. Para configurar el navegador para que lo haga, cree una variable de ambiente llamada SSLKEYLOGFILE y asígnele el nombre de ruta de un archivo en el que se escribirán las claves. El Decoder aceptará el archivo exactamente como se escribe y usará todas las claves de descifrado en el archivo para todo el tráfico cifrado que capture.

Este es un ejemplo del script NwConsole que el archivo carga en un Decoder:

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

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

Este es un ejemplo del uso de un comando curl (con el puerto RESTful) para cargar el archivo en 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"

Después de que se cargan las claves simétricas, se usan inmediatamente para cualquier descifrado que sea necesario. Las claves simétricas se almacenan en la memoria y hay un límite para la cantidad que se puede almacenar en cualquier momento específico. Cuando se agregan más claves, las claves más antiguas quedan obsoletas. También puede agregar claves de premaster pasando los parámetros random y premaster a sslKeys.

Claves privadas o archivos PEM

Normalmente, las claves privadas se almacenan en archivos PEM y son las claves asimétricas generadas por los servicios que aceptan el tráfico de TLS. Estas claves se usan durante el protocolo de enlace TLS para cifrar la clave simétrica de premaster que se usará para el resto del cifrado de carga útil.

Por ejemplo, si tiene un servidor web donde desea ver el tráfico, debe cargar la clave privada que usa para cifrar el tráfico. Solo debe hacerlo una vez, puesto que se almacena permanentemente (o hasta que se quita con un comando de eliminación). Las claves privadas se cifran automáticamente antes de almacenarlas para protegerlas. Después de la carga, debe emitir un comando de recarga de analizador de modo que la clave recién instalada se vuelva visible para el analizador HTTPS. Ahora, todos los protocolos de enlace TLS que usan esa clave privada se podrán descifrar con el Decoder.

Nota: No todos los conjuntos de aplicaciones de cifrado usan una clave privada “conocida” (por ejemplo, Ephemeral Diffie Hellman). No se puede descifrar el tráfico cifrado con esos cifrados, a menos que la clave de premaster se cargue en el Decoder antes del análisis de la sesión.

Estos son algunos ejemplos de comandos que cargan un archivo PEM que se usará para el descifrado.

Uso de NwConsole:

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

Mediante la interfaz RESTful (debe proporcionar el parámetro pemFilename en la 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"

Cargar varias claves de premaster y privadas

Puede usar el formulario de la interfaz RESTful para facilitar la carga de varias claves, premaster y privadas, al mismo tiempo.

  1. Abra la API RESTful en el navegador y vaya a esta ruta en el Decoder que desea configurar: /decoder/sslkeys.
    This is an example of the RESTful interface form.
  2. Junto a Cargar archivo 1, haga clic en Elegir archivo y busque el archivo de clave de premaster o el archivo PEM que desea cargar en el sistema de archivos local.
  3. (Opcional) Repita estos pasos para Cargar archivo 2 y Cargar archivo 3.
    This is an example of the RESTful interface form with additional uploads.
  4. Haga clic en Cargar.
    Los archivos se cargan en el Decoder y los resultados se muestran en el formulario.
    This is an example of the RESTful interface form with results.

Parámetros para la administración de claves

El comando sslKeys tiene varios parámetros para la administración de claves de premaster y privadas. Esta es la lista completa de parámetros:

                                   
ParámetroDescripción
clear Quita todas las claves de premaster de la memoria. No elimina ningún archivo PEM instalado en el sistema.
maxKeys Cambia el número máximo de claves de premaster que se almacenan en la memoria.
listPems Muestra una lista de todos los archivos PEM de claves privadas instalados.
deletePem Elimina el archivo PEM con nombre desde el sistema de archivos. Este parámetro se puede pasar más de una vez para quitar varios archivos.
random El hash aleatorio que se usa para identificar la clave de premaster.
premaster La clave de premaster que se instalará para el parámetro random anterior. Se deben mostrar en pares y random debe estar en primer lugar.

Valores de retorno

La mayoría de los comandos sslKeys devuelve pares de nombre/valor de estadísticas acerca de las claves de premaster en la memoria. Las estadísticas se enumeran en la siguiente tabla.

                           
NombreDescripción
added La cantidad de claves de premaster que se acaba de agregar durante este comando.
total La cantidad total de claves de premaster cargadas en la memoria.
agedOut La cantidad total de claves de premaster que se quitaron durante este comando; esta no es una estadística de duración.
maxKeys El máximo permitido de claves de premaster

Visualización del tráfico sin cifrar

Si los paquetes se descifran durante la etapa de análisis, los paquetes cifrados se escriben en el disco y la clave de premaster coincidente que se usa para descifrar se escribe en la clave de metadatos tls.premaster, los analistas pueden ver los paquetes sin cifrar mediante la clave de metadatos tls.premaster.

Una API del Decoder que puede usar para ver los paquetes sin cifrar es el servicio RESTful /sdk/content. Debe conocer el ID de sesión de los paquetes cifrados y el parámetro flags enmascarado en el valor 128 (o 0x80 en hexadecimal). Dirija el navegador a la interfaz RESTful del Decoder y escriba el siguiente comando, sustituyendo el ID de sesión real por <id>:

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

El Decoder despliega una página web simple que muestra los paquetes después de que se descifran.

Si desea ver el aspecto de los paquetes cifrados, escriba uno de los siguientes comandos, sustituyendo el ID de sesión por <id>:

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

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

Para obtener más información sobre el servicio /sdk/content, consulte la página del manual de /sdk content.

Suites de cifrado compatibles

En la siguiente tabla se enumeran las suites de cifrado que son compatibles con el uso de claves privadas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
Nombre de la suite de cifrado (RFC)Nombre (OpenSSL)Suite de cifradoVersión de TLSIntercam. de clavesFIPSClave privada
TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384ECDHE-RSA-AES256-GCM-SHA384[0xc030]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384ECDHE-ECDSA-AES256-GCM-SHA384[0xc02c]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384ECDHE-RSA-AES256-SHA384[0xc028]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384ECDHE-ECDSA-AES256-SHA384[0xc024]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHAECDHE-RSA-AES256-SHA[0xc014]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHAECDHE-ECDSA-AES256-SHA[0xc00a]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_256_GCM_SHA384DHE-DSS-AES256-GCM-SHA384[0xa3]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384DHE-RSA-AES256-GCM-SHA384[0x9f]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256DHE-RSA-AES256-SHA256[0x6b]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_256_CBC_SHA256DHE-DSS-AES256-SHA256[0x6a]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_256_CBC_SHADHE-RSA-AES256-SHA[0x39]SSLv3Kx=DHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_256_CBC_SHADHE-DSS-AES256-SHA[0x38]SSLv3Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHADHE-RSA-CAMELLIA256-SHA[0x88]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHADHE-DSS-CAMELLIA256-SHA[0x87]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384ECDH-RSA-AES256-GCM-SHA384[0xc032]SSLv3Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384ECDH-ECDSA-AES256-GCM-SHA384[0xc02e]TLSv1.2Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384ECDH-RSA-AES256-SHA384[0xc02a]TLSv1.2Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384ECDH-ECDSA-AES256-SHA384[0xc026]TLSv1.2Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_ECDH_RSA_WITH_AES_256_CBC_SHAECDH-RSA-AES256-SHA[0xc00f]SSLv3Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHAECDH-ECDSA-AES256-SHA[0xc005]SSLv3Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_RSA_WITH_AES_256_GCM_SHA384AES256-GCM-SHA384[0x9d]TLSv1.2Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_AES_256_CBC_SHA256AES256-SHA256[0x3d]TLSv1.2Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_AES_256_CBC_SHAAES256-SHA[0x35]SSLv3Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_CAMELLIA_256_CBC_SHACAMELLIA256-SHA[0x84]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHAECDHE-RSA-DES-CBC3-SHA[0xc012]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHAECDHE-ECDSA-DES-CBC3-SHA[0xc008]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHAEDH-RSA-DES-CBC3-SHA[0x16]SSLv3Kx=DHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHAEDH-DSS-DES-CBC3-SHA[0x13]SSLv3Kx=DHCumple con la normaNo compatible
TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHAECDH-RSA-DES-CBC3-SHA[0xc00d]SSLv3Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHAECDH-ECDSA-DES-CBC3-SHA[0xc003]SSLv3Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_RSA_WITH_3DES_EDE_CBC_SHADES-CBC3-SHA[0x0a]SSLv3Kx=RSACumple con la normaCompatible
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256ECDHE-RSA-AES128-GCM-SHA256[0xc02f]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256ECDHE-ECDSA-AES128-GCM-SHA256[0xc02b]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256ECDHE-RSA-AES128-SHA256[0xc027]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256ECDHE-ECDSA-AES128-SHA256[0xc023]TLSv1.2Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHAECDHE-RSA-AES128-SHA[0xc013]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHAECDHE-ECDSA-AES128-SHA[0xc009]SSLv3Kx=ECDHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_128_GCM_SHA256DHE-DSS-AES128-GCM-SHA256[0xa2]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256DHE-RSA-AES128-GCM-SHA256[0x9e]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256DHE-RSA-AES128-SHA256[0x67]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_128_CBC_SHA256DHE-DSS-AES128-SHA256[0x40]TLSv1.2Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_AES_128_CBC_SHADHE-RSA-AES128-SHA[0x33]SSLv3Kx=DHCumple con la normaNo compatible
TLS_DHE_DSS_WITH_AES_128_CBC_SHADHE-DSS-AES128-SHA[0x32]SSLv3Kx=DHCumple con la normaNo compatible
TLS_DHE_RSA_WITH_SEED_CBC_SHADHE-RSA-SEED-SHA[0x9a]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_DHE_DSS_WITH_SEED_CBC_SHADHE-DSS-SEED-SHA[0x99]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHADHE-RSA-CAMELLIA128-SHA[0x45]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHADHE-DSS-CAMELLIA128-SHA[0x44]SSLv3Kx=DHNo cumple con las normasNo compatible
TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256ECDH-RSA-AES128-GCM-SHA256[0xc031]TLSv1.2Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256ECDH-ECDSA-AES128-GCM-SHA256[0xc02d]TLSv1.2Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256ECDH-RSA-AES128-SHA256[0xc029]TLSv1.2Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256ECDH-ECDSA-AES128-SHA256[0xc025]TLSv1.2Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_ECDH_RSA_WITH_AES_128_CBC_SHAECDH-RSA-AES128-SHA[0xc00e]SSLv3Kx=ECDH/RSACumple con la normaNo compatible
TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHAECDH-ECDSA-AES128-SHA[0xc004]SSLv3Kx=ECDH/ECDSACumple con la normaNo compatible
TLS_RSA_WITH_AES_128_GCM_SHA256AES128-GCM-SHA256[0x9c]TLSv1.2Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_AES_128_CBC_SHA256AES128-SHA256[0x3c]TLSv1.2Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_AES_128_CBC_SHAAES128-SHA[0x2f]SSLv3Kx=RSACumple con la normaCompatible
TLS_RSA_WITH_SEED_CBC_SHASEED-SHA[0x96]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_RSA_WITH_CAMELLIA_128_CBC_SHACAMELLIA128-SHA[0x41]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_RSA_WITH_IDEA_CBC_SHAIDEA-CBC-SHA[0x07]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_ECDHE_RSA_WITH_RC4_128_SHAECDHE-RSA-RC4-SHA[0xc011]SSLv3Kx=ECDHNo cumple con las normasNo compatible
TLS_ECDHE_ECDSA_WITH_RC4_128_SHAECDHE-ECDSA-RC4-SHA[0xc007]SSLv3Kx=ECDHNo cumple con las normasNo compatible
TLS_ECDH_RSA_WITH_RC4_128_SHAECDH-RSA-RC4-SHA[0xc00c]SSLv3Kx=ECDH/RSANo cumple con las normasNo compatible
TLS_ECDH_ECDSA_WITH_RC4_128_SHAECDH-ECDSA-RC4-SHA[0xc002]SSLv3Kx=ECDH/ECDSANo cumple con las normasNo compatible
TLS_RSA_WITH_RC4_128_SHARC4-SHA[0x05]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_DHE_RSA_WITH_DES_CBC_SHAEDH-RSA-DES-CBC-SHA[0x15]SSLv3Kx=RSANo cumple con las normasNo compatible
TLS_DHE_DSS_WITH_DES_CBC_SHAEDH-DSS-DES-CBC-SHA[0x12]SSLv3Kx=DSSNo cumple con las normasNo compatible
TLS_RSA_WITH_DES_CBC_SHADES-CBC-SHA[0x09]SSLv3Kx=RSANo cumple con las normasCompatible
TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHAEXP-EDH-RSA-DES-CBC-SHA[0x14]SSLv3Kx=DSSNo cumple con las normasNo compatible
TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHAEXP-EDH-DSS-DES-CBC-SHA[0x11]SSLv3Kx=DSSNo cumple con las normasNo compatible
TLS_RSA_EXPORT_WITH_DES40_CBC_SHAEXP-DES-CBC-SHA[0x08]SSLv3Kx=DESNo cumple con las normasCompatible

Aplicación de hash al certificado TLS

El Network Decoder puede producir hashes de certificados que se ven en el flujo de paquetes. Estos hashes son el valor SHA-1 de cualquier certificado con codificación DER encontrado durante un protocolo de enlace TLS. Los hashes producidos se pueden utilizar para comparar el tráfico de red con hashes de listas negras SSL públicas, como la de sslbl.abuse.ch.

La característica de aplicación de hash al certificado TLS está deshabilitada de manera predeterminada. Se puede habilitar agregando la opción del analizador:

HTTPS="cert.sha1=true"

a la configuración /decoder/parsers/config/parsers.options de un Network Decoder.

Cuando esta opción está habilitada, el valor SHA-1 se almacena como un valor de texto en la clave metadatos:

cert.checksum

You are here
Table of Contents > Procedimientos adicionales de Decoder y Log Decoder > Descifrar los paquetes entrantes

Attachments

    Outcomes