Como posso listar os conjuntos de cifras SSL/TLS que um website em particular oferece?

Eu escrevi um guião para testar as suites de cifras. Ele recebe uma lista de suites de cifras suportadas pelo OpenSSL e tenta se conectar usando cada uma delas. Se o aperto de mão for bem sucedido, ele imprime YES. Se o aperto de mão não for bem sucedido, imprime NO, seguido pelo texto de erro do 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

Aqui está um exemplo de saída mostrando 3 cifras não suportadas, e 1 cifra suportada:

[@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

EDIT: Adiciona flexibilidade como anfitrião e porta são fornecidos como parâmetro para o script

Nmap com ssl-enum-ciphers

Não existe uma forma melhor ou mais rápida de obter uma lista de cifras disponíveis a partir de um serviço de rede. Além disso, nmap irá fornecer uma classificação de força de forte, fraca ou desconhecida para cada cifra disponível.

Primeiro, faça o download do script ssl-enum-ciphers.nse nmap explicação aqui ). Depois do mesmo directório do script, corra o nmap da seguinte forma:

List ciphers suportados por um servidor HTTP

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

List ciphers suportados por um servidor IMAP

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

Aqui está um snippet de saída de um servidor IMAP 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 alguma ferramenta que possa testar o que as cifras SSL/TLS oferecem num determinado website?

Sim, pode usar a ferramenta online no website SSL Labs ’ para consultar a Base de Dados do Servidor SSL Público.

Aqui está um snippet de informação que fornece:

(screenshot dos resultados do google.com)

Testa a ligação com TLS e SSL (e o script de construção pode ligar-se à sua própria cópia do OpenSSL para que versões obsoletas do SSL também sejam verificadas) e relatórios sobre os conjuntos de cifras e certificado do servidor.

Exemplo de saída para google.com (aparado para legibilidade):

$ 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

Uma vez que este é um tópico de referência tão bom para ferramentas de digitalização SSL, vou listar o CipherScan que foi criado há um ano e que também pode identificar problemas com cifras de troca de chaves https://github.com/jvehent/cipherscan

Se quiser o meu garfo que suporta SNI e FreeBSD, o URL i https://github. com/oparoz/cipherscan

É um script que chama openssl s_client e suporta usando seu próprio binário OpenSSL para que você possa testar as próximas funcionalidades ou novas cifras (chacha20+poly1305 por exemplo).

Também lhe permite ligar-se a qualquer porta que queira e usar starttlss.

Aqui está uma saída 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

E aqui está uma lista de opções

-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.

A saída json é útil se estiver a chamar isto a partir de outros scripts.

https://github.com/iSECPartners/sslyze

Este é baseado em Python, funciona em Linux/Mac/Windows a partir da linha de comando.

Após um pequeno googling encontrei este Testing for SSL-TLS (OWASP-CM-001) :

O scanner nmap , através da opção de scan “-sV”, é capaz de identificar serviços SSL. Os scanners de vulnerabilidades, para além de realizarem a descoberta de serviços, podem incluir verificações contra cifras fracas (por exemplo, o scanner Nessus tem a capacidade de verificar serviços SSL em portas arbitrárias, e irá reportar cifras fracas).

e também: O Foundstone SSL Digger é uma ferramenta para avaliar a força dos servidores SSL, testando as cifras suportadas. Algumas destas cifras são conhecidas por serem inseguras.

Estou usando para a maioria dos testes SSL testssl.sh (veja https://testssl.sh / devel version @ https://github.com/drwetter/testssl.sh . Ele testa vulnerabilidades, cifras, protocolos, etc.

Se você quiser uma boa saída grepable (e suporte para verificar todas as versões SSL/TLS)

Utilização: ./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 é ótimo; uma nova ferramenta SSLDiagnos funciona para Windows, ou você pode simplesmente escrever um script usando o openssl s\l s_client.

Baseado na resposta de @indiv e sugestão de publicá-la como sua própria resposta, estou fornecendo a minha versão ajustada do script de @indiv. Você pode fornecer um host como primeiro argumento, e ele irá produzir os mesmos resultados que o script original, mas um pouco mais formatado:

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

Existe um pequeno script em pentesterscripting.com para utilizar tanto SSLScan como OpenSSL para verificar:

• SSL v2;
• Fatos de cifras da semana;
• MD5; e
• TLS Renegotiation vulnerability http://www. pentesterscripting.com/discovery/ssl_tests (via Internet Archive Máquina de Wayback )

Duplicado aqui para futura impermeabilidade pois o site principal está agora morto:

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

Utilização: ./ssltest.sh HOST PORT

O script ssl-enum-ciphers do Nmap pode listar as cifras e as versões SSL/TLS suportadas, bem como os compressores suportados.

O (gratuito) OpenSSL Cookbook de Ivan Ristić, que desenvolveu a ferramenta online SSL Labs mencionada em Kez’s answer , afirma:

Se pretende determinar todas as suites suportadas por um determinado servidor, comece por invocar openssl ciphers ALL para obter uma lista de todas as suites suportadas pela sua versão do OpenSSL. Depois submeta-as ao servidor uma a uma para as testar individualmente. Não estou a sugerir que o faça manualmente; esta é uma situação em que um pouco de automatização vai muito longe. Na verdade, esta é uma situação em que ** procurar uma boa ferramenta pode ser apropriado**.

Existe, no entanto, uma desvantagem em testar desta forma. Você só pode testar as suites que o OpenSSL suporta. …

** Nenhuma biblioteca SSL/TLS suporta todos os conjuntos de cifras** , o que dificulta os testes exaustivos. Para os Laboratórios SSL, ** recorri ao uso de apertos de mão parciais para este fim, com um cliente personalizado que finge suportar suites arbitrárias**. Na verdade não pode negociar nem mesmo uma única suite, mas apenas propor a negociação é suficiente para que os servidores lhe digam se suportam ou não uma suite. Não só pode testar todas as suites desta forma, como também o pode fazer de forma muito eficiente.

(A minha ênfase.)

Uma ferramenta que não vi mencionada noutras respostas é o SSLTest de Stephen Bradshaw, que, entre outras coisas, se destina a comparar “as cifras e protocolos detectados com as normas de conformidade, tais como DSD ISM e PCI-DSS”. “

Então, experimente esta ou uma das ferramentas mencionadas nas outras respostas, ou então construa a sua própria e considere utilizar a abordagem do Ristić de apertos de mão parciais.

Esta resposta resume as melhores respostas dadas sofar e argumenta porque escolher uma alternativa (ou não!)._

Para encontrar a melhor solução, devemos primeiro responder “porque queremos enumerar todas as cifras suportadas? Aqui o foco está no aspecto da segurança, ou seja, para descobrir se um servidor é ou não vulnerável. A próxima pergunta a responder é se a saída deve ser legível por máquina, por exemplo, para ser mais utilizada num script, ou não.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Verifica vulnerabilidades conhecidas
• Auto-contido (não é necessária instalação)
• Suporta 370 cifras (a partir da versão 3.1) incluindo cifras depreciadas (não incluídas em versões mais recentes openSSL)
• Produz resultados legíveis por máquina (CSV e JSON)
• (em paralelo)
• Slow

Talvez a vantagem mais importante do testssl.sh em relação às seguintes alternativas seja a utilização de um conjunto de binários adaptados para testes de vulnerabilidade (leia a explicação do desenvolvedor aqui ).

2. cipherscan ](https://github.com/mozilla/cipherscan)

• CLI (python)
• No TLSv1.3
• Self-contained
• Limited cipher suites (hard-coded)
• Produces machinereadable results (JSON)
• Fast

3.

• Rápido

• Rápido

3.

SSLyze, inicialmente em https://github.com/iSECPartners/sslyze , está agora em https://github.com/nabla-c0d3/sslyze . Foi mencionado em outra resposta , mas sem muito detalhe.

SSLyze é baseado em Python, e funciona em Linux/Mac/Windows a partir da linha de comando. Ele usa OpenSSL, e no Windows, ele vem com uma cópia em pacote do OpenSSL.

Lists protocols, cipher suites, e detalhes chave, além de testes para algumas vulnerabilidades comuns. É possível activar ou desactivar determinadas verificações, para obter mais dados ou acelerar o scan.

Escrevi uma ferramenta que faz exactamente isso. Chama-se tlsenum e está disponível em 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

Aqui está um exemplo de saída da ferramenta contra twitter.com.

É semelhante ao que o SSL Lab’s faz mas acho que ter uma ferramenta de linha de comando que se pode automatizar e analisar é muito mais útil.

Todas estas respostas são positivas. Uma parte da resposta poderia explicar porque precisamos de uma ferramenta para descobrir a lista de servidores e não perguntar directamente em TLS que o servidor dá todas as suas suites de cifras suportadas, tal como o cliente TLS faz quando se liga a um servidor.

A resposta é que server não envia nunca uma lista , apenas selecciona na lista de cifras do cliente a cifra que quer utilizar, esta é a forma como o protocolo SSL/TLS está escrito : http://wiki. opensslfoundation.com/index.php/SSL_and_TLS_Protocols#Cipher_Suites

É por isso que o cliente tem de enumerar cifras para poder encontrar as suportadas pelo servidor e para isso fazer pelo menos um novo aperto de mão inicial (ClientHello) para cada conjunto de cifras.

A única coisa que se pode fazer é tentar todas elas, uma de cada vez, e ver quais são aceites. Não tenho conhecimento de uma ferramenta para o fazer, embora não deva ser difícil juntar uma de ferramentas de scripting e openssl s_client.

Enquanto o cliente anuncia quais as cifras que vai aceitar, o servidor simplesmente escolhe uma e usa-a ou falha a ligação se não encontrar nada que lhe agrade.

O TestSSLServer é uma solução baseada exclusivamente em Java. Vantagens:

• funciona a um nível muito baixo, apenas em Sockets simples, portanto é independente de possíveis cifras indisponíveis de JDK ou OpenSSL*.

• não necessita de portas adicionais (como ICMP para ping) para ser aberto

• funciona com certificados de clientes presentes

Desvantagens:

• a partir de 2016, a lista de cifras pode estar desactualizada (embora eu não seja especialista aqui para julgar isto)

A minha experiência pessoal: dado um servidor apertado com apenas uma porta HTTPS aberta (nenhuma outra porta), certificados de cliente requeridos e iptables activos, ainda era capaz de listar as cifras disponíveis, enquanto que as soluções mais populares não o eram (estava a tentar um pequeno script de shell, SSL Labs, NMap, sslscan)

Enquanto procurava algo que faz AUTH TLS sobre FTP, descobri esta ferramenta: (https://labs.portcullis.co.uk/tools/ssl-cipher-suite-enum/)

É um script perl que basicamente faz o que o script shell do hackajar faz, apenas mais sofisticado.

Também oferece uma avaliação básica das cifras e protocolos oferecidos. É um pouco como as ferramentas SSL Labs, apenas para uso doméstico. :)

Por defeito, apenas suporta AUTH SSL em FTP, mas uma simples pesquisa e substituição pode corrigir isso. Como bónus, também afirma suportar SMTP com STARTTLS e RDP.