¿Cómo puedo obtener una lista de las suites de cifrado SSL/TLS que ofrece un sitio web en particular?

Escribí un guión bash para probar las suites de cifrado. Obtiene una lista de las suites de cifrado soportadas por OpenSSL e intenta conectarse usando cada una de ellas. Si el apretón de manos tiene éxito, se imprime YES. Si el apretón de manos no tiene éxito, se imprime NO, seguido del texto de error de OpenSSL.

#!/usr/bin/env bash

# OpenSSL requires the port number.
SERVER=$1
DELAY=1
ciphers=$(openssl ciphers 'ALL:eNULL' | sed -e 's/:/ /g')

echo Obtaining cipher list from $(openssl version).

for cipher in ${ciphers[@]}
do
echo -n Testing $cipher...
result=$(echo -n | openssl s_client -cipher "$cipher" -connect $SERVER 2>&1)
if [["$result" =~ ":error:"]] ; then
  error=$(echo -n $result | cut -d':' -f6)
  echo NO \($error\)
else
  if [["$result" =~ "Cipher is ${cipher}" || "$result" =~ "Cipher :"]] ; then
    echo YES
  else
    echo UNKNOWN RESPONSE
    echo $result
  fi
fi
sleep $DELAY
done

Aquí hay un ejemplo de salida que muestra 3 cifrados no soportados, y 1 cifrado soportado:

[@linux ~]$ ./test_ciphers 192.168.1.11:443
Obtaining cipher list from OpenSSL 0.9.8k 25 Mar 2009.
Testing ADH-AES256-SHA...NO (sslv3 alert handshake failure)
Testing DHE-RSA-AES256-SHA...NO (sslv3 alert handshake failure)
Testing DHE-DSS-AES256-SHA...NO (sslv3 alert handshake failure)
Testing AES256-SHA...YES

EDITAR: Añade flexibilidad ya que el host y el puerto se proporcionan como parámetro al script

Nmap con ssl-enum-cifras

No hay una forma mejor o más rápida de obtener una lista de cifrados disponibles de un servicio de red. Además, nmap proporcionará una clasificación de fuerza de fuerte, débil o desconocida para cada cifrado disponible.

Primero, descargue el script ssl-enum-ciphers.nse nmap explicación aquí ). Luego, desde el mismo directorio que el script, ejecute nmap de la siguiente manera:

Lista de cifrados soportados por un servidor HTTP

$ nmap --script ssl-enum-ciphers -p 443 www.example.com

Lista de cifrados soportados por un servidor IMAP

$ nmap --script ssl-enum-ciphers -p 993 mail.example.com

Aquí hay un fragmento de la salida de un servidor IMAP de Dovecot:

993/tcp open imaps
| ssl-enum-ciphers:
| SSLv3:
| ciphers:
| TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA - strong
| TLS_DHE_RSA_WITH_AES_128_CBC_SHA - strong
| TLS_DHE_RSA_WITH_AES_256_CBC_SHA - strong
| TLS_RSA_WITH_IDEA_CBC_SHA - weak
...
| TLSv1.0:
| ciphers:
| TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA - strong
| TLS_DHE_RSA_WITH_AES_128_CBC_SHA - strong
| TLS_DHE_RSA_WITH_AES_256_CBC_SHA - strong
| TLS_RSA_WITH_IDEA_CBC_SHA - weak
...
|_ least strength: weak

Nmap done: 1 IP address (1 host up) scanned in 1.03 seconds

¿Existe alguna herramienta que pueda probar las suites de cifrado SSL/TLS que ofrece un sitio web en particular?

Sí, puedes usar la herramienta en línea del sitio web de SSL Labs ’ para consultar la base de datos del servidor público SSL.

Aquí tienes un fragmento de la información que proporciona:

(captura de pantalla de los resultados de google.com)

sslscan es una pequeña y agradable utilidad.

Prueba la conexión con TLS y SSL (y el script de construcción puede enlazar con su propia copia de OpenSSL para que las versiones obsoletas de SSL se comprueben también) e informa sobre las suites de cifrado y el certificado del servidor.

Ejemplo de salida para google.com (recortado para la legibilidad):

$ sslscan google.com
Testing SSL server google.com on port 443

 TLS renegotiation:
Secure session renegotiation supported

  TLS Compression:
Compression disabled

  Heartbleed:
TLS 1.2 not vulnerable to heartbleed
TLS 1.1 not vulnerable to heartbleed
TLS 1.0 not vulnerable to heartbleed

  Supported Server Cipher(s):
Preferred TLSv1.2 128 bits ECDHE-RSA-AES128-GCM-SHA256 Curve P-256 DHE 256
Accepted TLSv1.2 128 bits ECDHE-RSA-AES128-SHA Curve P-256 DHE 256
Accepted TLSv1.2 128 bits ECDHE-RSA-RC4-SHA Curve P-256 DHE 256
Accepted TLSv1.2 128 bits AES128-GCM-SHA256
Accepted TLSv1.2 128 bits AES128-SHA
<snip>
Preferred TLSv1.1 128 bits ECDHE-RSA-AES128-SHA Curve P-256 DHE 256
Accepted TLSv1.1 128 bits ECDHE-RSA-RC4-SHA Curve P-256 DHE 256
Accepted TLSv1.1 128 bits AES128-SHA
<snip>
Preferred TLSv1.0 128 bits ECDHE-RSA-AES128-SHA Curve P-256 DHE 256
Accepted TLSv1.0 128 bits ECDHE-RSA-RC4-SHA Curve P-256 DHE 256
Accepted TLSv1.0 128 bits AES128-SHA
<snip>
Preferred SSLv3 128 bits RC4-SHA
Accepted SSLv3 128 bits RC4-MD5
<snip>

  SSL Certificate:
Signature Algorithm: sha256WithRSAEncryption
RSA Key Strength: 2048

Subject: *.google.com
Altnames: DNS:*.google.com, DNS:*.android.com, <snip>
Issuer: Google Internet Authority G2

Not valid before: Apr 7 08:24:31 2016 GMT
Not valid after: Jun 30 08:20:00 2016 GMT

Como este es un gran hilo de referencia para las herramientas de escaneo SSL, listaré CipherScan que fue creado hace un año y también puede identificar problemas con los códigos de intercambio de claves https://github.com/jvehent/cipherscan

Si quieres mi tenedor que soporta SNI y FreeBSD, la URL i https://github. com/oparoz/cipherscan

Es un script que llama a openssl s_client y soporta el uso de su propio binario OpenSSL para que pueda probar las próximas características o nuevos cifrados (chacha20+poly1305 por ejemplo).

También te permite conectarte a cualquier puerto que quieras y usar starttlss.

Aquí hay una salida típica

# ./cipherscan -o ./openssl api.mycompany.com:443
...................
prio ciphersuite protocols pfs_keysize
1 DHE-RSA-AES256-GCM-SHA384 TLSv1.2 DH,4096bits
2 DHE-RSA-AES256-SHA256 TLSv1.2 DH,4096bits
3 ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 ECDH,P-384,384bits
4 ECDHE-RSA-AES256-SHA384 TLSv1.2 ECDH,P-384,384bits
5 DHE-RSA-AES128-GCM-SHA256 TLSv1.2 DH,4096bits
6 DHE-RSA-AES128-SHA256 TLSv1.2 DH,4096bits
7 ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 ECDH,P-384,384bits
8 ECDHE-RSA-AES128-SHA256 TLSv1.2 ECDH,P-384,384bits
9 DHE-RSA-CAMELLIA256-SHA TLSv1,TLSv1.1,TLSv1.2 DH,4096bits
10 DHE-RSA-AES256-SHA TLSv1,TLSv1.1,TLSv1.2 DH,4096bits
11 ECDHE-RSA-AES256-SHA TLSv1,TLSv1.1,TLSv1.2 ECDH,P-384,384bits
12 DHE-RSA-CAMELLIA128-SHA TLSv1,TLSv1.1,TLSv1.2 DH,4096bits
13 DHE-RSA-AES128-SHA TLSv1,TLSv1.1,TLSv1.2 DH,4096bits
14 ECDHE-RSA-AES128-SHA TLSv1,TLSv1.1,TLSv1.2 ECDH,P-384,384bits
15 CAMELLIA256-SHA TLSv1,TLSv1.1,TLSv1.2
16 AES256-SHA TLSv1,TLSv1.1,TLSv1.2
17 CAMELLIA128-SHA TLSv1,TLSv1.1,TLSv1.2
18 AES128-SHA TLSv1,TLSv1.1,TLSv1.2

Certificate: trusted, 4096 bit, sha256WithRSAEncryption signature
TLS ticket lifetime hint: 300
OCSP stapling: supported

Y aquí hay una lista de opciones

-a | --allciphers Test all known ciphers individually at the end.
-b | --benchmark Activate benchmark mode.
-d | --delay Pause for n seconds between connections
-D | --debug Output ALL the information.
-h | --help Shows this help text.
-j | --json Output results in JSON format.
-o | --openssl path/to/your/openssl binary you want to use.
-v | --verbose Increase verbosity.

La salida json es útil si estás llamando a esto desde otros scripts.

https://github.com/iSECPartners/sslyze

Este está basado en Python, funciona en Linux/Mac/Windows desde la línea de comandos.

Después de un poco de google encontré esto Testing for SSL-TLS (OWASP-CM-001) :

El escáner nmap , a través de la opción de escaneo “-sV”, es capaz de identificar los servicios SSL. Los Escáneres de Vulnerabilidad, además de realizar descubrimiento de servicios, pueden incluir comprobaciones contra cifrados débiles (por ejemplo, el escáner Nessus tiene la capacidad de comprobar los servicios SSL en puertos arbitrarios, e informará de los cifrados débiles).

y también: Foundstone SSL Digger es una herramienta para evaluar la fuerza de los servidores SSL probando los cifrados soportados. Se sabe que algunos de estos cifrados son inseguros.

Estoy usando para la mayoría de las pruebas de SSL testssl.sh (ver https://testssl.sh / versión devel @ https://github.com/drwetter/testssl.sh . Se prueba para las vulnerabilidades, cifrados, protocolos, etc.

Si quieres una salida grepable agradable (y soporte para comprobar todas las versiones SSL/TLS)

Uso: ./script.sh www.url.com

#!/usr/bin/env bash
ciphers2=$(openssl ciphers -ssl2 'ALL:eNULL' | sed -e 's/:/ /g')
ciphers3=$(openssl ciphers -ssl3 'ALL:eNULL' | sed -e 's/:/ /g')
cipherst1=$(openssl ciphers -tls1 'ALL:eNULL' | sed -e 's/:/ /g')
cipherst11=$(openssl ciphers -tls1.1 'ALL:eNULL' | sed -e 's/:/ /g')
cipherst12=$(openssl ciphers -tls1.2 'ALL:eNULL' | sed -e 's/:/ /g')

SSL2="SSL2("
for cipher in ${ciphers2[@]}
do
result=$(echo -n | openssl s_client -ssl2 -cipher "$cipher" -connect $1:443 2>&1)
if [["$result" =~ "Cipher is ${cipher}"]] ; then
  SSL2="${SSL2}${cipher}:"
fi
done
SSL2=$(echo "${SSL2})" | sed -e 's/:)/)/g')

SSL3="SSL3("
for cipher in ${ciphers3[@]}
do
result=$(echo -n | openssl s_client -ssl3 -cipher "$cipher" -connect $1:443 2>&1)
if [["$result" =~ "Cipher is ${cipher}"]] ; then
  SSL3="${SSL3}${cipher}:"
fi
done
SSL3=$(echo "${SSL3})" | sed -e 's/:)/)/g')
TLS1="TLS1("
for cipher in ${cipherst1[@]}
do
result=$(echo -n | openssl s_client -tls1 -cipher "$cipher" -connect $1:443 2>&1)
if [["$result" =~ "Cipher is ${cipher}"]] ; then
  TLS1="${TLS1}${cipher}:"
fi
done
TLS1=$(echo "${TLS1})" | sed -e 's/:)/)/g')

TLS11="TLS1.1("
for cipher in ${cipherst11[@]}
do
result=$(echo -n | openssl s_client -tls1_1 -cipher "$cipher" -connect $1:443 2>&1)
if [["$result" =~ "Cipher is ${cipher}"]] ; then
  TLS11="${TLS11}${cipher}:"
fi
done
TLS11=$(echo "${TLS11})" | sed -e 's/:)/)/g')

TLS12="TLS1.2("
for cipher in ${cipherst12[@]}
do
result=$(echo -n | openssl s_client -tls1_2 -cipher "$cipher" -connect $1:443 2>&1)
if [["$result" =~ "Cipher is ${cipher}"]] ; then
  TLS12="${TLS12}${cipher}:"
fi
done
TLS12=$(echo "${TLS12})" | sed -e 's/:)/)/g')

echo "$1,$SSL2,$SSL3,$TLS1,$TLS11,$TLS12";

SSLScan es genial; una nueva herramienta SSLDiagnos funciona para Windows, o puedes simplemente escribir un script usando el s_cliente de openssl.

Basado en la respuesta de @indiv y la sugerencia de publicarlo como su propia respuesta, estoy proporcionando mi versión ajustada del script de @indiv. Puedes proporcionar un host como primer argumento, y dará los mismos resultados que el script original, pero con un poco más de formato:

#!/usr/bin/env bash
# adapted from https://superuser.com/questions/109213/how-do-i-list-the-ssl-tls-cipher-suites-a-particular-website-offers

# OpenSSL requires the port number.
# SERVER=192.168.1.1:443
SERVER=$1
if [[-z "$SERVER"]]; then echo "ERROR: no server specified"; exit 1; fi;

## Set up colors, if possible
if [[$(tput colors)]];then
  COLOR_BOLD="$(tput bold)" # "\e[1;32m"
  COLOR_GREEN="$(tput setaf 2)" # "\e[1;32m"
  COLOR_RESET="$(tput sgr0)" # "\e[0m"
fi

SERVER=$1:443
echo Server is ${COLOR_BOLD}"$SERVER"${COLOR_RESET}

DELAY=1
ciphers=$(openssl ciphers 'ALL:eNULL' | sed -e 's/:/ /g')

echo Obtaining cipher list from $(openssl version).

for cipher in ${ciphers[@]}
  do
  printf "%-42s" "Testing $cipher... "
  result=$(echo -n | openssl s_client -cipher "$cipher" -connect $SERVER 2>&1)
  if [["$result" =~ ":error:"]] ; then
    error=$(echo -n $result | cut -d':' -f6)
    echo NO \($error\)
  else
    if [["$result" =~ "Cipher is ${cipher}" || "$result" =~ "Cipher :"]] ; then
      echo ${COLOR_BOLD}${COLOR_GREEN}YES${COLOR_RESET}
    else
      echo UNKNOWN RESPONSE
      echo $result
    fi
  fi
  sleep $DELAY
done

Hay un pequeño script en pentesterscripting.com para utilizar tanto SSLScan como OpenSSL para comprobar:

• SSL v2;
• Trajes de cifrado de semana;
• MD5; y
• Vulnerabilidad de renegociación TLS http://www. pentesterscripting.com/discovery/ssl_tests (via the Internet Archive Wayback Machine )

Duplicado aquí para futureproofing ya que el sitio principal está ahora muerto:

#!/usr/bin/env bash

# Description:
# Script to extract the most security relevant details from a 
# target SSL/TLS implementation by using sslscan.
# Author: Raul Siles (raul _AT_ taddong _DOT_ com)
# Taddong (www.taddong.com)
# Date: 2011-05-27
# Version: 1.0
#
# - Current SSL/TLS tests: 
# SSLv2, NULL cipher, weak ciphers -key length-, strong 
# ciphers -AES-, MD5 signed cert, SSL/TLS renegotiation
#
# Requires: 
# - sslscan
# https://sourceforge.net/projects/sslscan/
#
# Credits: Based on ssl_test.sh by Aung Khant, http://yehg.net.
# 

#
# / **************************************************************************
# * Copyright 2011 by Taddong (Raul Siles) *
# * *
# * This program is free software; you can redistribute it and/or modify *
# * it under the terms of the GNU General Public License as published by *
# * the Free Software Foundation; either version 3 of the License, or *
# * (at your option) any later version. *
# * *
# * This program is distributed in the hope that it will be useful, *
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
# * GNU General Public License for more details. *
# * *
# * You should have received a copy of the GNU General Public License *
# * along with this program. If not, see <http://www.gnu.org/licenses/>. *
# * *
# ************************************************************************** /
#

VERSION=1.0

OPENSSLVERSION=$(openssl version)
SSLSCANVERSION=$(sslscan --version | grep version | sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g")

echo ------------------------------------------------------
echo " TLSSLed - ($VERSION) based on sslscan and openssl"
echo " by Raul Siles (www.taddong.com)"
echo " ( inspired by ssl_test.sh by Aung Khant )"
echo ------------------------------------------------------
echo + openssl version: $OPENSSLVERSION
echo + $SSLSCANVERSION
echo ------------------------------------------------------
echo

if [$# -ne 2]; then 
   echo Usage: $0 IP PORT
   exit
fi

HOST=$1
PORT=$2

echo [*] Analyzing SSL/TLS on $HOST:$PORT ...
echo 

# Run sslcan once, store the results to a log file and
# analyze that file for all the different tests:
DATE=$(date +%F_%R:%S)
TARGET=$HOST:$PORT
LOGFILE=sslscan\_$TARGET\_$DATE.log
ERRFILE=sslscan\_$TARGET\_$DATE.err

echo [*] Running sslscan on $HOST:$PORT...
sslscan $HOST:$PORT > $LOGFILE 2> $ERRFILE

echo
echo [*] Testing for SSLv2 ...
cat $LOGFILE | grep "Accepted SSLv2"
echo
echo [*] Testing for NULL cipher ...
cat $LOGFILE | grep "NULL" | grep Accepted
echo
echo [*] Testing for weak ciphers \(based on key length\) ...
cat $LOGFILE | grep " 40 bits" | grep Accepted
echo 
cat $LOGFILE | grep " 56 bits" | grep Accepted
echo
echo [*] Testing for strong ciphers \(AES\) ...
cat $LOGFILE | grep "AES" | grep Accepted

echo 
echo [*] Testing for MD5 signed certificate ...
#cat $LOGFILE | grep -E 'MD5WithRSAEncryption|md5WithRSAEncryption'
cat $LOGFILE | grep -i 'MD5WithRSAEncryption'

echo 
echo [*] Checking preferred server ciphers ...
cat $LOGFILE | sed '/Prefered Server Cipher(s):/,/^$/!d' | sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g"

echo
echo [*] Testing for SSLv3/TLSv1 renegotiation vuln. \(CVE-2009-3555\) ...
#echo [*] echo R \| openssl s_client -connect $HOST:$PORT \| grep "DONE"
#
# Renegotiation details go to stderr (2>)
#
# if $OPENSSLVERSION is updated (version?) it supports RFC5746 and will print:
# Secure Renegotiation IS NOT supported
# Secure Renegotiation IS supported
#

echo R | openssl s_client -connect $HOST:$PORT | grep -E "Secure Renegotiation IS|DONE"

echo
echo [*] New files created:
ls -l $LOGFILE
if [! -s $ERRFILE]; then
        # Error file is empty
        rm $ERRFILE
else
        ls -l $ERRFILE
fi

echo
echo 
echo [*] done
echo

Uso: ./ssltest.sh PUERTO DE ACOGIDA

El script de Nmap ssl-enum-cifras puede listar los cifrados y versiones SSL/TLS soportados, así como los compresores soportados.

El (gratuito) OpenSSL Cookbook de Ivan Ristić, quien desarrolló la herramienta online SSL Labs anotada en la respuesta de Kez , dice:

Si quieres determinar todas las suites soportadas por un servidor en particular, comienza invocando openssl ciphers ALL para obtener una lista de todas las suites soportadas por tu versión de OpenSSL. Luego envíelas al servidor una por una para probarlas individualmente. No estoy sugiriendo que lo haga manualmente; esta es una situación en la que un poco de automatización llega muy lejos. De hecho, esta es una situación en la que buscar una buena herramienta podría ser apropiado.

Sin embargo, hay una desventaja en probar de esta manera. Sólo puedes probar las suites que OpenSSL soporta. …

Ninguna librería SSL/TLS soporta todas las suites de cifrado, y eso dificulta las pruebas exhaustivas. Para SSL Labs, recurrí a usar handshakes parciales para este propósito, con un cliente personalizado que pretende soportar suites arbitrarias. En realidad, no puede negociar ni siquiera una sola suite, pero el simple hecho de proponer negociar es suficiente para que los servidores te digan si soportan una suite o no. No sólo se pueden probar todas las suites de esta manera, sino que también se puede hacer muy eficientemente.

(Mi énfasis.)

Una herramienta que no he visto mencionada en otras respuestas es la SSLTest de Stephen Bradshaw, que, entre otras cosas, tiene por objeto comparar “los cifrados y protocolos detectados con las normas de cumplimiento como DSD ISM y PCI-DSS. ”

Así que, pruebe esta o una de las herramientas mencionadas en las otras respuestas, o bien construya la suya propia y considere usar el enfoque de Ristić de apretones de manos parciales.

Esta respuesta resume las respuestas mejor dadas sofar y argumenta por qué elegir una alternativa (¡o no!)._

Para encontrar la mejor solución, primero debemos responder “¿por qué queremos enumerar todos los cifrados soportados?”. Aquí el foco está en el aspecto de la seguridad, es decir, en averiguar si un servidor es vulnerable o no. La siguiente pregunta a responder es si la salida debe ser legible para la máquina, por ejemplo, para ser usada más adelante en un script, o no.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Comprueba si hay vulnerabilidades conocidas
• Autónomo (no necesita instalación)
• Soporta 370 cifrados (a partir de la versión 3.1) incluyendo cifrados obsoletos (no incluidos en las nuevas versiones de openSSL)
• Produce resultados legibles por máquina (CSV y JSON)
• (paralelizado) procesamiento por lotes
• Lento

Tal vez la ventaja más importante de testssl.sh sobre las siguientes alternativas es el uso de un conjunto de binarios que están adaptados para las pruebas de vulnerabilidad (leer la explicación del desarrollador aquí ).

2. cipherscan

• CLI (python)
• No TLSv1.3
• Autocontenido
• Suites de cifrado limitado (hard-coded)
• Produce resultados legibles por máquina (JSON)
• Rápido

3. nmap ssl-enum-ciphers

• CLI (nmap script)
• No TLSv1.3
• Autocontenido
• Suites de cifrado limitado (hard-coded)
• Comprueba las vulnerabilidades conocidas
• No hay resultados legibles por máquina

Para una visión general exhaustiva de las herramientas disponibles ver sslLabs Assessment Tools .

SSLyze, originalmente en https://github.com/iSECPartners/sslyze , está ahora en https://github.com/nabla-c0d3/sslyze . Fue mencionado en otra respuesta , pero sin muchos detalles.

SSLyze está basado en Python, y funciona en Linux/Mac/Windows desde la línea de comandos. Utiliza OpenSSL, y en Windows, viene con una copia de OpenSSL.

Lista protocolos, suites de cifrado, y detalles de las claves, además de pruebas para algunas vulnerabilidades comunes. Es posible activar o desactivar determinadas comprobaciones, para obtener más datos o acelerar el escaneo.

Escribí una herramienta que hace exactamente esto. Se llama tlsenum y está disponible en GitHub .

[ayrx@division tlsenum]$ ./tlsenum.py twitter.com 443
TLS Versions supported by server: 3.0, 1.0, 1.1, 1.2
Supported Cipher suites in order of priority:
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_RSA_WITH_RC4_128_SHA
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_AES_128_GCM_SHA256
TLS_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_RC4_128_MD5
TLS_RSA_WITH_AES_128_CBC_SHA
TLS_RSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_3DES_EDE_CBC_SHA

Aquí hay un ejemplo de la salida de la herramienta contra twitter.com.

Es similar a lo que hace SSL Lab’s pero encuentro que tener una herramienta de línea de comandos que puedes automatizar y analizar es mucho más útil.

Todas esas respuestas están bien. Una parte de la respuesta podría explicar por qué necesitamos una herramienta para descubrir la lista de servidores y no preguntar directamente en TLS que el servidor da todas sus suites de cifrado soportadas como lo hace el cliente TLS cuando se conecta a un servidor.

La respuesta es que el servidor no envía una lista nunca , sólo selecciona en la lista de cifrado del cliente el cifrado que quiere usar, así es como se escribe el protocolo SSL/TLS : [ http://wiki. opensslfoundation.com/index.php/SSL y protocolos #Cifrado de Suites (http://wiki.opensslfoundation.com/index.php/SSL_and_TLS_Protocols#Cipher_Suites)

Por eso el cliente tiene que enumerar los cifrados para poder encontrar aquellos soportados por el servidor y para ello hacer al menos un nuevo inicio de apretón de manos (ClienteHola) para cada suite de cifrado.

Lo único que puedes hacer es probarlas todas, una a una, y ver cuáles son aceptadas. No conozco una herramienta para hacer esto, aunque no debería ser difícil de improvisar una a partir de las herramientas de scripting y openssl s_client.

Mientras que el cliente anuncia cuáles son los cifrados que aceptará, el servidor simplemente escoge uno y lo usa o falla la conexión si no encuentra nada que le guste.

El TestSSLServer (http://www.bolet.org/TestSSLServer/) es una solución basada puramente en Java. Ventajas:

• funciona a muy bajo nivel, sólo en Sockets planos, por lo que es independiente de posibles códigos no disponibles de JDK u OpenSSL.

• no requiere que se abran puertos adicionales (como ICMP para ping)

• está funcionando con certificados de cliente presentes

Desventajas:

• a partir de 2016, la lista de cifrados podría estar desactualizada (aunque no soy un experto aquí para juzgar esto)

Mi experiencia personal: dado un servidor muy ajustado con un solo puerto HTTPS abierto (no hay otro puerto), se requieren certificados de cliente y las iptables están activas, todavía era capaz de listar los cifrados disponibles, mientras que las soluciones más votadas no lo estaban (estaba intentando con un pequeño script de shell, SSL Labs, NMap, sslscan)

Mientras buscaba algo que hiciera AUTH TLS en el FTP, descubrí esta herramienta: ssl-cipher-suite-enum

Es un script perl que básicamente hace lo que hace el shell script de hackajar, sólo que más sofisticado.

También ofrece una evaluación básica de los cifrados y protocolos ofrecidos. Es algo así como las herramientas de SSL Labs, sólo para uso doméstico. :)

Por defecto, sólo soporta AUTH SSL en FTP, pero una simple búsqueda y reemplazo puede arreglar eso. Como bonus, también dice que soporta SMTP con STARTTLS y RDP.