Come posso elencare le suite di cifratura SSL/TLS offerte da un particolare sito web?

Ho scritto un copione di bash per testare le suite di cifratura. Esso ottiene da OpenSSL un elenco delle suite di cifratura supportate e cerca di connettersi utilizzando ciascuna di esse. Se la stretta di mano ha successo, stampa YES. Se l'handshake non ha successo, stampa NO, seguito dal testo di errore di 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
``` ```
[@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

Ecco un esempio di output che mostra 3 cifrari non supportati, e 1 cifrario supportato:

&001

EDIT: aggiungere flessibilità come host e porta sono forniti come parametro allo script

Nmap con ssl-enum-ciphers

Non esiste un modo migliore o più veloce per ottenere una lista dei cifrari disponibili da un servizio di rete. Inoltre, nmap fornirà una valutazione di forza di forte, debole o sconosciuto per ogni cifrario disponibile.

Innanzitutto, scaricare lo script ssl-enum-ciphers.nse nmap spiegazione qui ). Poi, dalla stessa directory dello script, eseguire nmap come segue:

Elenca i cifrari supportati da un server HTTP

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

Elenca i cifrari supportati da un server IMAP

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

Ecco un frammento di output da un server 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

Esiste uno strumento in grado di testare le suite di cifratura SSL/TLS offerte da un particolare sito web?

Sì, è possibile utilizzare lo strumento online sul sito web SSL Labs ’ per interrogare il database pubblico del server SSL.

Ecco un frammento di informazioni che fornisce:

(screenshot dei risultati di google.com)

sslscan è una piccola utility.

Test di connessione con TLS e SSL (e lo script di compilazione può collegarsi con la propria copia di OpenSSL in modo che vengano controllate anche le versioni obsolete di SSL) e rapporti sulle suite di cifratura del server e sul certificato.

Uscita di esempio per google.com (tagliata per la leggibilità):

$ 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

Dato che questo è un ottimo filo di riferimento per gli strumenti di scansione SSL, elencherò CipherScan che è stato creato un anno fa e può anche identificare problemi con i cifrari di scambio di chiavi https://github.com/jvehent/cipherscan

Se volete il mio fork che supporta SNI e FreeBSD, l'URL i https://github. com/oparoz/cipherscan

È uno script che chiama openssl s_client e supporta l'uso del proprio binario OpenSSL in modo da poter testare le prossime funzionalità o i nuovi cifrari (chacha20+poly1305 per esempio).

Consente inoltre di collegarsi a qualsiasi porta si desideri e di utilizzare starttlss.

Ecco una tipica uscita

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

Ed ecco una lista di opzioni

-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.
``` &001 


L'uscita json è utile se la si chiama da altri script.

https://github.com/iSECPartners/sslyze &003

Questo è basato su Python, funziona in Linux/Mac/Windows da riga di comando.

Dopo un piccolo googling ho trovato questo Test per SSL-TLS (OWASP-CM-001) :

Lo scanner nmap , tramite l'opzione di scansione “-sV”, è in grado di identificare i servizi SSL. Gli scanner di vulnerabilità, oltre ad eseguire il rilevamento dei servizi, possono includere controlli contro i cifrari deboli (per esempio, lo scanner Nessus scanner ha la capacità di controllare i servizi SSL su porte arbitrarie, e segnalerà i cifrari deboli).

e anche: Foundstone SSL Digger è uno strumento per valutare la forza dei server SSL testando i cifrari supportati. Alcuni di questi cifrari sono noti per essere insicuri.

Sto usando per la maggior parte dei test SSL testssl.sh (vedi https://testssl.sh / devel version @ https://github.com/drwetter/testssl.sh . Esso testa le vulnerabilità, i cifrari, i protocolli, ecc.

Se si desidera un bell'output grepable (e il supporto per il controllo di tutte le versioni SSL/TLS)

Usage: ./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 è fantastico; un nuovo strumento SSLDiagnos funziona per Windows, oppure si può semplicemente scrivere uno script usando il client openssl s _client.

Sulla base della risposta di @indiv risposta e del suggerimento di pubblicarla come risposta propria, sto fornendo la mia versione modificata dello script di @indiv. Si può fornire un host come primo argomento, e produrrà gli stessi risultati dello script originale, ma un po’ più formattato:

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

C'è un piccolo e simpatico script su pentesterscripting.com per utilizzare sia SSLScan che OpenSSL per controllare:

• SSL v2;
• Week ciphers suits;
• MD5;
• TLS Renegotiation vulnerability http://www. pentesterscripting.com/discovery/ssl_tests (tramite l'Archivio Internet Wayback Machine )

Duplicato qui per il futureproofing in quanto il sito principale è ora 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
``` &001 


Useage: ./ssltest.sh PORTO HOST

Lo script ssl-enum-ciphers di Nmap può elencare i cifrari supportati e le versioni SSL/TLS, così come i compressori supportati.

Il (gratuito) OpenSSL Cookbook di Ivan Ristić, che ha sviluppato lo strumento online SSL Labs indicato nella risposta di Kez , afferma:

Se si desidera determinare tutte le suite supportate da un particolare server, iniziare invocando openssl ciphers ALL per ottenere una lista di tutte le suite supportate dalla propria versione di OpenSSL. Poi inviatele al server una ad una per testarle singolarmente. Non vi sto suggerendo di farlo manualmente; questa è una situazione in cui un po’ di automazione fa molta strada. In realtà, questa è una situazione in cui ** cercare un buon strumento potrebbe essere appropriato**.

C'è uno svantaggio nel testare in questo modo, tuttavia. Si possono testare solo le suite che OpenSSL supporta. …

** Nessuna singola libreria SSL/TLS supporta tutte le suite di cifratura** , e questo rende difficile un test completo. Per i laboratori SSL, Ho fatto ricorso all'uso di strette di mano parziali per questo scopo, con un client personalizzato che finge di supportare suite arbitrarie. In realtà non può negoziare nemmeno una singola suite, ma il solo fatto di proporre di negoziare è sufficiente perché i server vi dicano se supportano o meno una suite. Non solo si possono testare tutte le suite in questo modo, ma si può anche farlo in modo molto efficiente.

(La mia enfasi.)

Uno strumento che non ho visto menzionato in altre risposte è SSLTest di Stephen Bradshaw, che, tra le altre cose, ha lo scopo di confrontare “i cifrari e i protocolli rilevati con gli standard di conformità come DSD ISM e PCI-DSS. ”

Quindi, provate questo o uno degli strumenti menzionati nelle altre risposte, oppure costruite il vostro e considerate di utilizzare l'approccio di Ristić di strette di mano parziali.

Questa risposta riassume le risposte migliori e spiega perché scegliere un'alternativa (o no!)._

Per trovare la soluzione migliore, dovremmo prima rispondere ‘perché vogliamo elencare tutti i cifrari supportati? Qui l'attenzione è focalizzata sull'aspetto della sicurezza, ovvero, per scoprire se un server è vulnerabile o meno. La prossima domanda a cui rispondere è se l'output deve essere leggibile dalla macchina, ad esempio, per essere ulteriormente utilizzato in uno script, oppure no.

1. testssl.sh (https://testssl.sh/testssl.1.html)

• CLI (Bash)
• TLSv1. 3
• Verifica delle vulnerabilità note
• Autocontenuta (non è necessaria l'installazione)
• Supporta 370 cifrari (dalla versione 3.1) compresi i cifrari deprecati (non inclusi nelle più recenti versioni openSSL)
• Produce risultati leggibili a macchina (CSV e JSON)
• (parallelizzato) elaborazione batch
• Lento

Forse il vantaggio più importante di testssl.sh rispetto alle seguenti alternative è l'uso di un insieme di binari che sono fatti su misura per i test di vulnerabilità (leggere la spiegazione dello sviluppatore qui ).

2. cipherscan (https://github.com/ssllabs/research/wiki/Assessment-Tools)

• CLI (pitone)
• No TLSv1.3
• Autocontenuto
• Suite di cifratura limitata (hard-coded)
• Produce risultati leggibili a macchina (JSON)
• Veloce

3. [ nmap ssl-enum-ciphers ]&003

• CLI (nmap script)
• No TLSv1.3
• Autocontenuto
• Suite di cifratura limitata (hard-coded)
• Controlli per vulnerabilità note
• Nessun risultato leggibile a macchina

Per una panoramica completa degli strumenti disponibili vedere [ sslLabs Assessment Tools ]&003.

SSLyze, originariamente a https://github.com/iSECPartners/sslyze , è ora a https://github.com/nabla-c0d3/sslyze . E’ stato menzionato in un'altra risposta , ma senza molti dettagli.

SSLyze è basato su Python, e funziona su Linux/Mac/Windows da riga di comando. Utilizza OpenSSL, e su Windows, viene fornito con una copia in bundle di OpenSSL.

elenca protocolli, suite di cifratura, e dettagli chiave, oltre a test per alcune vulnerabilità comuni. È possibile abilitare o disabilitare particolari controlli, per ottenere più dati o velocizzare la scansione.

Ho scritto uno strumento che fa esattamente questo. Si chiama tlsenum ed è disponibile su 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
``` &001 


Ecco un output di esempio dello strumento contro `twitter.com`. 


È simile a quello che fa SSL Lab ma trovo che avere uno strumento a riga di comando che si può automatizzare e analizzare sia molto più utile.

Tutte queste risposte vanno bene. Una parte della risposta potrebbe spiegare perché abbiamo bisogno di uno strumento per scoprire la lista dei server e non chiedere direttamente in TLS che il server dia tutte le sue suite di cifratura supportate proprio come fa il client TLS quando si connette ad un server.

La risposta è che server non invia mai una lista , si limita a selezionare nella lista dei cifrari del client il cifrario che vuole usare, questo è il modo in cui è scritto il protocollo SSL/TLS : http://wiki. opensslfoundation.com/index.php/SSLandTLS__Protocols#Cipher_Suites

Ecco perché il client deve enumerare i cifrari per poter trovare quelli supportati dal server e per questo deve fare almeno una nuova stretta di mano (ClientHello) per ogni suite di cifrario.

L'unica cosa che si può fare è provarli tutti, uno alla volta, e vedere quali sono accettati. Non sono a conoscenza di uno strumento per fare questo, anche se non dovrebbe essere difficile metterne insieme uno tra gli strumenti di scripting e openssl s_client.

Mentre il client pubblicizza quale cifrario accetterà, il server ne sceglie semplicemente uno e lo usa o fallisce la connessione se non trova nulla di suo gradimento.

TestSSLServer è una soluzione puramente basata su Java. Vantaggi:

• funziona a bassissimo livello, solo su semplici Sockets, quindi è indipendente da possibili cifrari non disponibili da JDK o OpenSSL.

• non richiede porte aggiuntive (come ICMP per il ping) per essere aperto

• funziona con i certificati dei clienti presenti

Svantaggi:

• a partire dal 2016, l'elenco dei cifrari potrebbe essere obsoleto (anche se non sono un esperto a giudicare questo)

La mia esperienza personale: dato un server con una sola porta HTTPS aperta (nessun'altra porta), certificati client richiesti e iptables attivi, era ancora in grado di elencare i cifrari disponibili, mentre le soluzioni top-voted non lo erano (stavo provando piccoli script shell, SSL Labs, NMap, sslscan)

Mentre cercavo qualcosa che facesse AUTH TLS su FTP, ho scoperto questo strumento: ssl-cipher-suite-enum

È uno script perl che fondamentalmente fa quello che fa lo script shell di hackajar, solo più sofisticato.

Offre anche una valutazione di base dei cifrari e dei protocolli offerti. È un po’ come gli strumenti SSL Labs, solo per uso domestico. :)

Per impostazione predefinita, supporta solo AUTH SSL su FTP, ma una semplice ricerca e sostituzione può risolvere il problema. Come bonus, sostiene anche di supportare SMTP con STARTTLS e RDP.