¿Cómo enumero las suites de cifrado SSL / TLS que ofrece un sitio web en particular?

¿Cómo puedo recuperar una lista de los conjuntos de cifrado SSL / TLS que ofrece un sitio web en particular?

Intenté openssl, pero si examina la salida:

$ echo -n | openssl s_client -connect www.google.com:443 
CONNECTED(00000003)
depth=1 /C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
verify error:num=20:unable to get local issuer certificate
verify return:0
---
Certificate chain
 0 s:/C=US/ST=California/L=Mountain View/O=Google Inc/CN=www.google.com
   i:/C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
 1 s:/C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
   i:/C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority
---
Server certificate
-----BEGIN CERTIFICATE-----
MIIDITCCAoqgAwIBAgIQL9+89q6RUm0PmqPfQDQ+mjANBgkqhkiG9w0BAQUFADBM
MQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhhd3RlIENvbnN1bHRpbmcgKFB0eSkg
THRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBDQTAeFw0wOTEyMTgwMDAwMDBaFw0x
MTEyMTgyMzU5NTlaMGgxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlh
MRYwFAYDVQQHFA1Nb3VudGFpbiBWaWV3MRMwEQYDVQQKFApHb29nbGUgSW5jMRcw
FQYDVQQDFA53d3cuZ29vZ2xlLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC
gYEA6PmGD5D6htffvXImttdEAoN4c9kCKO+IRTn7EOh8rqk41XXGOOsKFQebg+jN
gtXj9xVoRaELGYW84u+E593y17iYwqG7tcFR39SDAqc9BkJb4SLD3muFXxzW2k6L
05vuuWciKh0R73mkszeK9P4Y/bz5RiNQl/Os/CRGK1w7t0UCAwEAAaOB5zCB5DAM
BgNVHRMBAf8EAjAAMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwudGhhd3Rl
LmNvbS9UaGF3dGVTR0NDQS5jcmwwKAYDVR0lBCEwHwYIKwYBBQUHAwEGCCsGAQUF
BwMCBglghkgBhvhCBAEwcgYIKwYBBQUHAQEEZjBkMCIGCCsGAQUFBzABhhZodHRw
Oi8vb2NzcC50aGF3dGUuY29tMD4GCCsGAQUFBzAChjJodHRwOi8vd3d3LnRoYXd0
ZS5jb20vcmVwb3NpdG9yeS9UaGF3dGVfU0dDX0NBLmNydDANBgkqhkiG9w0BAQUF
AAOBgQCfQ89bxFApsb/isJr/aiEdLRLDLE5a+RLizrmCUi3nHX4adpaQedEkUjh5
u2ONgJd8IyAPkU0Wueru9G2Jysa9zCRo1kNbzipYvzwY4OA8Ys+WAi0oR1A04Se6
z5nRUP8pJcA2NhUzUnC+MY+f6H/nEQyNv4SgQhqAibAxWEEHXw==
-----END CERTIFICATE-----
subject=/C=US/ST=California/L=Mountain View/O=Google Inc/CN=www.google.com
issuer=/C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
---
No client certificate CA names sent
---
SSL handshake has read 1777 bytes and written 316 bytes
---
New, TLSv1/SSLv3, Cipher is AES256-SHA
Server public key is 1024 bit
Compression: NONE
Expansion: NONE
SSL-Session:
    Protocol  : TLSv1
    Cipher    : AES256-SHA
    Session-ID: 748E2B5FEFF9EA065DA2F04A06FBF456502F3E64DF1B4FF054F54817C473270C
    Session-ID-ctx: 
    Master-Key: C4284AE7D76421F782A822B3780FA9677A726A25E1258160CA30D346D65C5F4049DA3D10A41F3FA4816DD9606197FAE5
    Key-Arg   : None
    Start Time: 1266259321
    Timeout   : 300 (sec)
    Verify return code: 20 (unable to get local issuer certificate)
---

solo muestra que el conjunto de cifrado es algo con AES256-SHA. Sé que podría atravesar el basurero hexadecimal de la conversación, pero esperaba algo un poco más elegante.

Preferiría hacer esto en Linux, pero Windows (u otro) estaría bien. Esta pregunta está motivada por las pruebas de seguridad que hago para PCI y las pruebas de penetración general.

Actualizar:

GregS señala a continuación que el servidor SSL selecciona de los conjuntos de cifrado del cliente. Entonces parece que necesitaría probar todas las suites de cifrado de una en una. Creo que puedo hackear algo juntos, pero ¿hay una manera más simple y a prueba de futuro (por ejemplo, nuevas cifras) para hacer esto?

Escribí un script bash para probar conjuntos de cifrado. Obtiene una lista de conjuntos de cifrado compatibles de OpenSSL e intenta conectarse usando cada uno. Si el apretón de manos es exitoso, 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 una salida de muestra que muestra 3 cifrados no compatibles y 1 cifrado compatible:

[@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: agregue flexibilidad ya que el host y el puerto se proporcionan como parámetro para el script

Nmap con ssl-enum-ciphers

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 desconocido para cada cifrado disponible.

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

Lista de cifrados compatibles con un servidor HTTP

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

Lista de cifrados compatibles con un servidor IMAP

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

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

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 qué conjuntos de cifrado SSL / TLS ofrece un sitio web en particular?

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

Aquí hay un fragmento de 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 compilación puede vincularse con su propia copia de OpenSSL para que también se verifiquen las versiones obsoletas de SSL) e informa sobre las suites y el certificado de cifrado del servidor.

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

$ 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 excelente hilo de referencia para las herramientas de escaneo SSL, enumeraré CipherScan que se creó hace un año y también puede identificar problemas con los cifrados de intercambio de claves. https://github.com/jvehent/cipherscan

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

Es un script que llama openssl s_clienty admite el uso de su propio binario OpenSSL para que pueda probar las próximas funciones o nuevos cifrados (chacha20 + poly1305 por ejemplo).

También te permite conectarte a cualquier puerto que desees 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á llamando 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 buscar un poco en Google, encontré esta prueba para SSL-TLS (OWASP-CM-001) :

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

y también: Foundstone SSL Digger es una herramienta para evaluar la fortaleza de los servidores SSL mediante la prueba de los cifrados admitidos. Se sabe que algunos de estos cifrados son inseguros.

Estoy usando para la mayoría de las pruebas SSL testssl.sh (consulte https://testssl.sh / devel version @ https://github.com/drwetter/testssl.sh . Comprueba vulnerabilidades, cifrados, protocolos, etc.

SSLScan es genial; una nueva herramienta SSLDiagnos funciona para Windows, o puede escribir un script usando el openssl s_client.

El script ssl-enum-ciphers de Nmap puede enumerar los cifrados compatibles y las versiones SSL / TLS, así como los compresores compatibles.

Si desea un buen resultado grepable (y soporte para verificar 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";

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

• SSL v2;
• Trajes de cifrados semanales;
• MD5; y
• Vulnerabilidad de renegociación de TLS

http://www.pentesterscripting.com/discovery/ssl_tests (a través de Internet Archive Wayback Machine )

Duplicado aquí para futuras pruebas ya que el sitio principal ahora está 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 ANFITRIÓN

Basado en la respuesta de @ indiv y la sugerencia de publicarlo como su propia respuesta, proporciono mi versión ajustada del script de @ indiv. Puede proporcionar un host como primer argumento, y generará los mismos resultados que el script original, pero un poco más formateado:

#!/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

El libro de cocina OpenSSL (gratuito) de Ivan Ristić, quien desarrolló la herramienta en línea SSL Labs que se menciona en la respuesta de Kez , dice:

Si desea determinar todas las suites compatibles con un servidor en particular, comience invocando openssl ciphers ALLpara obtener una lista de todas las suites compatibles con su versión de OpenSSL. Luego envíelos al servidor uno por uno para probarlos individualmente. No estoy sugiriendo que hagas esto manualmente; Esta es una situación en la que un poco de automatización es muy útil. De hecho, esta es una situación en la que buscar una buena herramienta puede ser apropiado .

Sin embargo, hay una desventaja en probar de esta manera. Solo puede probar las suites que admite OpenSSL. ...

Ninguna biblioteca SSL / TLS es compatible con todos los conjuntos de cifrado , y eso dificulta las pruebas exhaustivas. Para SSL Labs, recurrí al uso de apretones de manos parciales para este propósito, con un cliente personalizado que pretende admitir suites arbitrarias . En realidad, no puede negociar ni una sola suite, pero solo proponiendo negociar es suficiente para que los servidores le digan si admiten una suite o no. No solo puede probar todas las suites de esta manera, sino que también puede hacerlo de manera muy eficiente.

(Mi énfasis)

Una herramienta que no he visto mencionada en otras respuestas es el SSLTest de Stephen Bradshaw , que, entre otras cosas, tiene la intención de comparar "los cifrados y protocolos detectados con los estándares de cumplimiento como DSD ISM y PCI-DSS".

Por lo tanto, pruebe esta o una de las herramientas mencionadas en las otras respuestas, o bien cree la suya propia y considere usar el enfoque de Ristić de apretones de manos parciales.

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 salida de la herramienta contra twitter.com.

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

SSLyze, originalmente en https://github.com/iSECPartners/sslyze , ahora está 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 incluida de OpenSSL.

Enumera protocolos, conjuntos de cifrado y detalles clave, además de pruebas para algunas vulnerabilidades comunes. Es posible habilitar o deshabilitar verificaciones particulares, obtener más datos o acelerar el escaneo.

Lo único que puede hacer es probarlos todos, uno a la vez, y ver cuáles son aceptados. No conozco una herramienta para hacer esto, aunque no debería ser difícil improvisar una de las herramientas de scripting y openssl s_client.

Mientras el cliente anuncia qué conjuntos de cifrado aceptará, el servidor simplemente elige uno y lo usa o falla la conexión si no encuentra nada que le guste.

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 ese servidor proporciona todas sus suites de cifrado compatibles al igual que el cliente TLS cuando se conecta a un servidor.

La respuesta es que el servidor nunca envía una lista , solo selecciona en la lista de cifrado del cliente el cifrado que quiere usar, esta es la forma en que se escribe el protocolo SSL / TLS: http://wiki.opensslfoundation.com/index.php/ SSL_and_TLS_Protocols # Cipher_Suites

Es por eso que el cliente tiene que enumerar los cifrados para poder encontrar aquellos compatibles con el servidor y para eso hacer al menos un nuevo protocolo de enlace de inicio (ClientHello) para cada conjunto de cifrado.

Mientras buscaba algo que funciona AUTH TLSen FTP, descubrí esta herramienta: ssl-cipher-suite-enum

Es un script perl que básicamente hace lo que hace el script shell de hackajar, solo 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, solo para uso doméstico. :)

Por defecto, solo es compatible AUTH SSLcon FTP, pero una simple búsqueda y reemplazo puede solucionarlo. Como beneficio adicional, también afirma que admite SMTP con STARTTLSy RDP.

TestSSLServer es una solución puramente basada en Java. Ventajas:

• funciona a muy bajo nivel, solo en Sockets simples, por lo que es independiente de posibles cifrados no disponibles de JDK u OpenSSL .

• no requiere que se abra ningún puerto adicional (como ICMP para ping)

• está trabajando con certificados de clientes 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 de enlace estrecho con un solo puerto HTTPS abierto (ningún otro puerto), se requieren certificados de cliente e iptables activo, todavía era capaz de enumerar los cifrados disponibles, mientras que las soluciones más votadas no estaban (estaba prueba de script de shell pequeño, SSL Labs, NMap, sslscan)