Como faço para listar as suítes de criptografia SSL / TLS que um determinado site oferece?

235

Como posso recuperar uma lista dos conjuntos de criptografia SSL / TLS que um determinado site oferece?

Eu tentei o openssl, mas se você examinar a saída:

$ 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)
---

apenas mostra que o conjunto de criptografia é algo com o AES256-SHA. Eu sei que eu poderia falar sobre o lixo hexadecimal da conversa, mas eu estava esperando por algo um pouco mais elegante.

Eu preferiria fazer isso no Linux, mas o Windows (ou outro) estaria bem. Esta questão é motivada pelos testes de segurança que faço para PCI e testes gerais de penetração.

Atualização:

GregS aponta abaixo que o servidor SSL escolhe os conjuntos de criptografia do cliente. Então, parece que eu precisaria testar todos os conjuntos de criptografia, um de cada vez. Eu acho que posso hackear algo juntos, mas existe uma maneira mais simples, mais à prova do futuro (por exemplo, novas cifras) para fazer isso?

    
por Jeremy Powell 15.02.2010 / 19:47

20 respostas

205

Eu escrevi um script bash para testar os pacotes de criptografia. Ele obtém uma lista de conjuntos de criptografia com suporte do OpenSSL e tenta se conectar usando cada um deles. Se o handshake for bem sucedido, imprime YES . Se o handshake não for bem-sucedido, ele 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

Veja a saída de exemplo que mostra 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: Adicione flexibilidade como host e porta são fornecidos como parâmetro para o script

    
por 21.12.2010 / 00:41
138

Nmap com ssl-enum -cifras

Não há maneira melhor ou mais rápida de obter uma lista de códigos disponíveis em um serviço de rede. Além disso, o nmap fornecerá uma classificação de força strong, fraca ou desconhecida para cada código disponível.

Primeiro, faça o download do script nmap ssl-enum-ciphers.nse ( explicação aqui ). Então, no mesmo diretório do script, execute o nmap da seguinte maneira:

Listar cifras suportadas por um servidor HTTP

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

Listar cifras suportadas por um servidor IMAP

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

Aqui está um trecho da saída de um 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
    
por 05.06.2014 / 11:29
96

Is there a tool that can test what SSL/TLS cipher suites a particular website offers?

Sim, você pode usar a ferramenta on-line no site SSL Labs 'para consultar o Banco de Dados do Servidor Público SSL.

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

(captura de tela dos resultados do google.com)

    
por 20.02.2010 / 19:02
49
O

sslscan é um bom utilitário.

Ele testa a conexão com o TLS e o SSL (e o script de construção pode vincular com sua própria cópia do OpenSSL para que versões SSL obsoletas também sejam verificadas) e relatórios sobre conjuntos de criptografia e certificados do servidor.

Exemplo de saída para google.com (reduzido 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
    
por 18.03.2010 / 23:21
14

Como esse é um excelente thread de referência para ferramentas de varredura SSL, listarei o CipherScan, que foi criado há um ano e também pode identificar problemas com cifras de troca de chaves. link

Se você quer meu fork que suporta SNI e FreeBSD, o URL é link

É um script que chama openssl s_client e suporta o uso de seu próprio binário OpenSSL para que você possa testar recursos futuros ou novas cifras (chacha20 + poly1305 por exemplo).

Ele também permite que você se conecte a qualquer porta desejada e use 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 do json é útil se você estiver chamando isso de outros scripts.

    
por 16.09.2014 / 13:25
12

link

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

    
por 25.01.2012 / 15:01
8

Após um pouco de googling, encontrei este Testes para SSL-TLS (OWASP- CM-001) :

The nmap scanner, via the “–sV” scan option, is able to identify SSL services. Vulnerability Scanners, in addition to performing service discovery, may include checks against weak ciphers (for example, the Nessus scanner has the capability of checking SSL services on arbitrary ports, and will report weak ciphers).

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

    
por 20.02.2010 / 17:30
4

Estou usando a maioria dos testes SSL testssl.sh (veja link / devel version @ link . Ele testa vulnerabilidades, cifras, protocolos, etc.

    
por 10.01.2015 / 18:36
2

SSLScan é ótimo; uma nova ferramenta SSLDiagnos funciona para Windows, ou você pode simplesmente escrever um script usando o s_client openssl.

    
por 01.12.2010 / 21:40
2

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

    
por 25.03.2014 / 22:58
2

Se você quiser uma boa saída grepable (e suporte para verificar todas as versões 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";
    
por 09.04.2014 / 20:31
2

Existe um pequeno script em pentesterscripting.com para utilizar o SSLScan e o OpenSSL para verificar:

  • SSL v2;
  • Fatos da semana de cifras;
  • MD5; e
  • Vulnerabilidade de renegociação TLS

link (através do Internet Archive Wayback Machine )

Duplicado aqui para o futuro, já que o site principal está 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

Uso: ./ssltest.sh HOST PORT

    
por 19.01.2012 / 06:39
2

Baseado em @ indiv's resposta e sugestão para postar como resposta própria, estou fornecendo minha versão do script do @ indiv. Você pode fornecer um host como o primeiro argumento e exibirá os mesmos resultados do 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
    
por 05.02.2016 / 01:55
1

Eu escrevi uma ferramenta que faz exatamente isso. É chamado de 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 faz, mas acho que ter uma ferramenta de linha de comando que você pode automatizar e analisar é muito mais útil.

    
por 25.05.2014 / 15:34
1

O (gratuito) OpenSSL Cookbook de Ivan Ristić, que desenvolveu a ferramenta on-line do SSL Labs em a resposta de Kez , afirma:

If you want to determine all suites supported by a particular server, start by invoking openssl ciphers ALL to obtain a list of all suites supported by your version of OpenSSL. Then submit them to the server one by one to test them individually. I am not suggesting that you do this manually; this is a situation in which a little automation goes a long way. In fact, this is a situation in which looking around for a good tool might be appropriate.

There is a disadvantage to testing this way, however. You can only test the suites that OpenSSL supports. ...

No single SSL/TLS library supports all cipher suites, and that makes comprehensive testing difficult. For SSL Labs, I resorted to using partial handshakes for this purpose, with a custom client that pretends to support arbitrary suites. It actually can’t negotiate even a single suite, but just proposing to negotiate is enough for servers to tell you if they support a suite or not. Not only can you test all the suites this way, but you can also do it very efficiently.

(minha ênfase.)

Uma ferramenta que eu não vi mencionada em outras respostas é o SSLTest de Stephen Bradshaw, que, entre outras coisas, , destina-se a comparar "as cifras e protocolos detectados com os padrões de conformidade, como DSD ISM e PCI-DSS".

Então, experimente esta ou uma das ferramentas mencionadas nas outras respostas, ou crie a sua própria e considere o uso da abordagem de handshakes parciais de Ristić.

    
por 19.09.2016 / 05:01
0

A única coisa que você pode fazer é experimentar todas elas, uma de cada vez, e ver quais são aceitas. Não tenho conhecimento de uma ferramenta para fazer isso, embora não seja difícil criar um conjunto de ferramentas de script e openssl s_client .

Enquanto o cliente anuncia quais ciphersuites ele aceitará, o servidor simplesmente escolhe um e usa ou falha na conexão se não encontrar nada que goste.

    
por 15.02.2010 / 22:51
0

Todas essas respostas estão bem. Uma parte da resposta poderia explicar por que precisamos de uma ferramenta para descobrir a lista de servidores e não perguntar diretamente no TLS que o servidor fornece todos os conjuntos de criptografia suportados, da mesma forma que o cliente TLS faz quando se conecta a um servidor.

A resposta é que o servidor não envia uma lista sempre , apenas seleciona na lista de cifras do cliente a cifra que deseja usar, é assim que o protocolo SSL / TLS é escrito: link

É por isso que o cliente precisa enumerar cifras para encontrar as suportadas pelo servidor e fazer pelo menos um novo handshake de início (ClientHello) para cada conjunto de criptografia.

    
por 04.11.2014 / 21:45
0

Enquanto procurava por algo que faz AUTH TLS no FTP, descobri essa ferramenta: ssl -cipher-suite-enum

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

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

Por padrão, ele suporta apenas AUTH SSL no FTP, mas uma pesquisa e substituição simples podem corrigir isso. Como bónus, também afirma apoiar o SMTP com STARTTLS e RDP.

    
por 21.12.2014 / 00:56
0

SSLyze, originalmente no link , agora está em link . Foi mencionado em outra resposta, mas sem muitos detalhes.

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

Relaciona protocolos, pacotes de criptografia e detalhes importantes, além de testes para algumas vulnerabilidades comuns. É possível ativar ou desativar determinadas verificações para obter mais dados ou acelerar a verificação.

    
por 26.09.2015 / 13:24
0

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

  • ele está trabalhando em um nível muito baixo, apenas em Sockets simples, por isso é independente de possíveis cifras não disponíveis do JDK ou OpenSSL .

  • não requer que portas adicionais (como ICMP para ping) sejam abertas

  • está trabalhando com certificados de cliente presentes

Desvantagens:

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

Minha experiência pessoal: dado um servidor tight-laced com apenas uma porta HTTPS aberta (nenhuma outra porta), certificados de cliente necessários e iptables sendo ativos, ainda era capaz de listar cifras disponíveis, enquanto as soluções mais votadas não eram (Eu estava tentando pequeno script shell, SSL Labs, NMap, sslscan)

    
por 02.03.2016 / 11:02