2010-02-15 18:47:18 +0000 2010-02-15 18:47:18 +0000
276
276

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

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

J'ai essayé openssl, mais si vous examinez le résultat :

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

, vous constaterez que la suite de chiffrement est quelque chose avec AES256-SHA. Je sais que je pourrais me débrouiller avec le dump hexadécimal de la conversation, mais j'espérais quelque chose d'un peu plus élégant.

Je préférerais faire ça sous Linux, mais Windows (ou autre) serait parfait. Cette question est motivée par les tests de sécurité que je fais pour le PCI et les tests de pénétration généraux.

Mise à jour:

GregS souligne ci-dessous que le serveur SSL choisit dans les suites de chiffrement du client. Il semble donc que je doive tester toutes les suites de chiffrement une à la fois. Je pense que je peux pirater quelque chose ensemble, mais existe-t-il un moyen plus simple et plus pérenne (par exemple, de nouveaux chiffres) de le faire ?

Réponses (21)

246
246
246
2010-12-20 23:41:17 +0000

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

170
170
170
2014-06-05 09:29:14 +0000

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
106
106
106
2010-02-20 18:02:27 +0000

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)

57
57
57
2010-03-18 22:21:08 +0000

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
15
15
15
2014-09-16 11:25:38 +0000

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.

13
13
13
2012-01-25 14:01:34 +0000

https://github.com/iSECPartners/sslyze

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

8
8
8
2010-02-20 16:30:05 +0000

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.

6
6
6
2015-01-10 17:36:14 +0000

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.

2
2
2
2014-04-09 18:31:47 +0000

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";
2
2
2
2010-12-01 20:40:29 +0000

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.

2
2
2
2016-02-05 00:55:55 +0000

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
2
2
2
2012-01-19 05:39:21 +0000

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

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

2
2
2
2014-03-25 21:58:08 +0000

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.

2
2
2
2016-09-19 03:01:09 +0000

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

1
1
1
2020-02-11 13:25:43 +0000

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 .

1
1
1
2015-09-26 11:24:14 +0000

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.

1
1
1
2014-05-25 13:34:41 +0000

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.

0
0
0
2014-11-04 20:45:59 +0000

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.

0
0
0
2010-02-15 21:51:27 +0000

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.

0
0
0
2016-03-02 10:02:12 +0000

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)
0
0
0
2014-12-20 23:56:37 +0000

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.