Comment puis-je obtenir la liste des suites de chiffrement SSL/TLS offertes par un site web particulier ?

J'ai écrit un script bash pour tester les suites de chiffrement. Il obtient une liste des suites de chiffrement supportées par OpenSSL et essaie de se connecter en utilisant chacune d'entre elles. Si la poignée de main est réussie, il imprime YES. Si la poignée de main n'aboutit pas, il affiche NO, suivi du texte d'erreur OpenSSL. Voici un exemple de sortie montrant 3 chiffrages non supportés et 1 chiffrage supporté :

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

EDIT : Ajouter de la flexibilité car l'hôte et le port sont fournis en paramètre au script

Nmap avec ssl-enum-ciphers

Il n'existe pas de moyen meilleur ou plus rapide d'obtenir une liste des chiffres disponibles auprès d'un service de réseau. De plus, nmap fournira une note de force (forte, faible ou inconnue) pour chaque chiffre disponible.

Tout d'abord, téléchargez le script de la carte ssl-enum-ciphers.nse nmap (explication ici ](http://nmap.org/nsedoc/scripts/ssl-enum-ciphers.html)). Ensuite, à partir du même répertoire que le script, lancez nmap comme suit :

Liste des chiffrages supportés par un serveur HTTP

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

Liste des chiffrages supportés par un serveur IMAP

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

Voici un extrait de la sortie d'un serveur 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-t-il un outil permettant de tester les suites de chiffrement SSL/TLS offertes par un site web particulier ?

Oui, vous pourriez utiliser l'outil en ligne du site web SSL Labs ’ pour interroger la base de données du serveur SSL public.

Voici un extrait des informations qu'il fournit :

(capture d'écran tirée des résultats de google.com)

Il teste la connexion avec TLS et SSL (et le script de compilation peut établir un lien avec sa propre copie d'OpenSSL afin que les versions obsolètes de SSL soient également vérifiées) et fournit des rapports sur les suites de chiffrement et le certificat du serveur. Exemple de sortie pour google.com (réduite pour des raisons de lisibilité) :

$ 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

Comme il s'agit d'un excellent fil de référence pour les outils d'analyse SSL, je vais énumérer CipherScan qui a été créé il y a un an et qui peut également identifier les problèmes de chiffrement des échanges de clés https://github.com/jvehent/cipherscan

Si vous voulez ma fourchette qui supporte SNI et FreeBSD, l'URL i https://github. com/oparoz/cipherscan

C'est un script qui appelle openssl s_client et qui supporte l'utilisation de votre propre binaire OpenSSL afin que vous puissiez tester les fonctionnalités à venir ou les nouveaux chiffrages (chacha20+poly1305 par exemple).

Il vous permet également de vous connecter à n'importe quel port et d'utiliser des starttlss.

Voici une sortie typique

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

Et voici une liste d'options

-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 sortie json est utile si vous appelez ceci depuis d'autres scripts.

https://github.com/iSECPartners/sslyze

Celui-ci est basé sur Python, fonctionne sous Linux/Mac/Windows en ligne de commande.

Après une petite recherche sur Google, j'ai trouvé ceci Testing for SSL-TLS (OWASP-CM-001) :

Le scanner nmap , via l'option de balayage “-sV”, est capable d'identifier les services SSL. Les scanners de vulnérabilité, en plus d'effectuer la découverte de services, peuvent inclure des vérifications par rapport à des chiffres faibles (par exemple, le scanner Nessus a la capacité de vérifier les services SSL sur des ports arbitraires, et signalera les chiffres faibles).

et aussi : Le Foundstone SSL Digger est un outil permettant d'évaluer la puissance des serveurs SSL en testant les chiffrages pris en charge. Certains de ces chiffres sont connus pour être peu sûrs.

J'utilise pour la plupart des tests SSL testssl.sh (voir https://testssl.sh / version devel @ https://github.com/drwetter/testssl.sh . Il teste les vulnérabilités, les chiffrages, les protocoles, etc.

Si vous voulez un résultat agréable (et un support pour vérifier toutes les versions 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 est génial ; un nouvel outil SSLDiagnos fonctionne pour Windows, ou vous pouvez simplement écrire un script en utilisant le client openssl s_client.

Sur la base de la réponse d’@indiv et de la suggestion de l'afficher comme sa propre réponse, je fournis ma version modifiée du script d’@indiv. Vous pouvez fournir un hôte comme premier argument, et il produira les mêmes résultats que le script original, mais un peu plus formaté :

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

Il y a un joli petit script sur pentesterscripting.com qui utilise SSLScan et OpenSSL pour vérifier :

• SSL v2 ;
• les combinaisons de chiffrement hebdomadaires ;
• MD5 ; et
• la vulnérabilité de renégociation TLS http://www. pentesterscripting.com/discovery/ssl_tests (via l'Internet Archive Wayback Machine )

Dupliqué ici pour la pérennité car le site principal est maintenant mort :

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

Usage : ./ssltest.sh HOST PORT

Le script ssl-enum-ciphers de Nmap peut énumérer les chiffres et les versions SSL/TLS supportés, ainsi que les compresseurs pris en charge.

Le (gratuit) OpenSSL Cookbook de Ivan Ristić, qui a développé l'outil en ligne SSL Labs mentionné dans la réponse de Kez , indique :

Si vous voulez déterminer toutes les suites supportées par un serveur particulier, commencez par invoquer openssl ciphers ALL pour obtenir la liste de toutes les suites supportées par votre version d'OpenSSL. Ensuite, soumettez-les au serveur une par une pour les tester individuellement. Je ne vous suggère pas de faire cela manuellement ; c'est une situation dans laquelle un peu d'automatisation fait beaucoup de chemin. En fait, c'est une situation dans laquelle chercher un bon outil pourrait être approprié.

Il y a cependant un inconvénient à tester de cette manière. Vous pouvez seulement tester les suites qu'OpenSSL supporte. …

Aucune bibliothèque SSL/TLS ne supporte toutes les suites de chiffrement, ce qui rend les tests complets difficiles. Pour les laboratoires SSL, j'ai eu recours à l'utilisation de poignées de main partielles à cette fin, avec un client personnalisé qui prétend supporter des suites arbitraires. En fait, il ne peut même pas négocier une seule suite, mais il suffit de proposer de négocier pour que les serveurs vous disent s'ils prennent en charge une suite ou non. Non seulement vous pouvez tester toutes les suites de cette manière, mais vous pouvez aussi le faire très efficacement.

(C'est moi qui souligne.)

Un outil que je n'ai pas vu mentionné dans les autres réponses est le SSLTest de Stephen Bradshaw, qui, entre autres, est destiné à comparer “les chiffres et protocoles détectés avec les normes de conformité telles que DSD ISM et PCI-DSS. ”

Donc, essayez cet outil ou l'un des outils mentionnés dans les autres réponses, ou bien construisez le vôtre et envisagez d'utiliser l'approche des poignées de main partielles de Ristić.

Cette réponse résume les meilleures réponses données jusqu'à présent et explique pourquoi il faut choisir une alternative (ou non !). Pour trouver la meilleure solution, nous devrions d'abord répondre “pourquoi voulons-nous énumérer tous les chiffres supportés ? Ici, l'accent est mis sur l'aspect sécurité, c'est-à-dire sur la nécessité de déterminer si un serveur est vulnérable ou non. La question suivante à laquelle il faut répondre est de savoir si la sortie doit être lisible par la machine, par exemple pour être utilisée dans un script, ou non.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Vérifie les vulnérabilités connues
• Autonome (pas d'installation nécessaire)
• Prend en charge 370 chiffres (à partir de la version 3.1) y compris les chiffres obsolètes (non inclus dans les nouvelles versions openSSL)
• Produit des résultats lisibles par machine (CSV et JSON)
• (parallélisé) traitement par lots
• Lent

Peut-être que l'avantage le plus important de testssl.sh par rapport aux alternatives suivantes est l'utilisation d'un ensemble de binaires qui sont adaptés pour les tests de vulnérabilité (lire l'explication du développeur ici ).

2. cipherscan

• CLI (python)
• Non TLSv1.3
• Autonome
• Suites de chiffrement limitées (codées en dur)
• Produit des résultats lisibles par machine (JSON)
• Rapide

3. nmap ssl-enum-ciphers ](https://nmap.org/nsedoc/scripts/ssl-enum-ciphers.html)

• CLI (nmap script)
• Pas de TLSv1.3
• Autonome
• Suites de chiffrement limitées (codées en dur)
• Vérifie les vulnérabilités connues
• Pas de résultats lisibles par machine

Pour un aperçu exhaustif des outils disponibles, voir sslLabs Assessment Tools .

SSLyze, initialement à l'adresse https://github.com/iSECPartners/sslyze , est maintenant à l'adresse https://github.com/nabla-c0d3/sslyze . Il a été mentionné dans une autre réponse , mais sans beaucoup de détails.

SSLyze est basé sur Python, et fonctionne sur Linux/Mac/Windows en ligne de commande. Il utilise OpenSSL, et sous Windows, il est fourni avec une copie d'OpenSSL.

Liste les protocoles, les suites de chiffrement et les détails clés, plus des tests pour certaines vulnérabilités communes. Il est possible d'activer ou de désactiver des contrôles particuliers, pour obtenir plus de données ou accélérer l'analyse.

J'ai écrit un outil qui fait exactement cela. Il s'appelle tlsenum et il est disponible sur 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

Voici un exemple de sortie de l'outil par rapport à twitter.com.

C'est similaire à ce que fait le SSL Lab mais je trouve qu'avoir un outil en ligne de commande que vous pouvez automatiser et analyser est beaucoup plus utile.

Toutes ces réponses sont bonnes. Une partie de la réponse pourrait expliquer pourquoi nous avons besoin d'un outil pour découvrir la liste des serveurs et ne pas demander directement dans TLS que le serveur donne toutes ses suites de chiffrement supportées comme le client TLS le fait quand il se connecte à un serveur.

La réponse est que le serveur n'envoie jamais de liste, il sélectionne juste dans la liste de chiffrement du client le chiffrement qu'il veut utiliser, c'est la façon dont le protocole SSL/TLS est écrit : http://wiki. opensslfoundation.com/index.php/SSL_and_TLS_Protocols#Cipher_Suites

C'est pourquoi le client doit énumérer les codes pour pouvoir trouver ceux qui sont pris en charge par le serveur et pour cela faire au moins une poignée de main de nouveau départ (ClientHello) pour chaque suite de codes.

La seule chose que vous pouvez faire est de les essayer toutes, une par une, et de voir lesquelles sont acceptées. Je ne connais pas d'outil permettant de faire cela, bien qu'il ne devrait pas être difficile d'en bricoler un à partir d'outils de script et de openssl s_client.

Alors que le client annonce quels chiffrages il acceptera, le serveur en choisit simplement un et l'utilise ou échoue la connexion s'il ne trouve rien qui lui plaise.

TestSSLServer est une solution purement basée sur Java. Avantages :

• il fonctionne à très bas niveau, juste sur des Sockets ordinaires, donc il est indépendant des éventuels chiffrages non disponibles de JDK ou OpenSSL. 002
• il ne nécessite pas l'ouverture de ports supplémentaires (comme ICMP pour le ping) 002
• il fonctionne avec les certificats clients présents 002 Inconvénients : 002
• à partir de 2016, la liste des chiffres pourrait être dépassée (bien que je ne sois pas un expert pour juger de cela) 002 Mon expérience personnelle : avec un serveur très étroit, avec un seul port HTTPS ouvert (aucun autre port), des certificats clients requis et iptables actif, il était toujours possible de lister les chiffres disponibles, alors que les solutions les plus populaires ne l'étaient pas (j'essayais un petit script shell, SSL Labs, NMap, sslscan)

En cherchant quelque chose qui fait AUTH TLS sur FTP, j'ai découvert cet outil : ssl-cipher-suite-enum

C'est un script perl qui fait essentiellement ce que fait le script shell de hackajar, mais en plus sophistiqué.

Il offre également une évaluation de base des chiffrages et protocoles proposés. C'est un peu comme les outils de SSL Labs, mais pour un usage domestique :)

Par défaut, il ne supporte que AUTH SSL sur FTP, mais une simple recherche et un remplacement peuvent régler ce problème. En bonus, il prétend également supporter le SMTP avec STARTTLS et RDP.