Comment répertorier les suites de chiffrement SSL / TLS offertes par un site Web particulier?

260

Comment puis-je récupérer une 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)
---

cela montre simplement que la suite de chiffrement est quelque chose avec AES256-SHA. Je savais que je pouvais passer à travers le vidage de la conversation, mais j'espérais quelque chose d'un peu plus élégant.

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

Mise à jour:

GregS indique ci-dessous que le serveur SSL choisit parmi les suites de chiffrement du client. Il semble donc que je devrais 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 évolutif (par exemple, de nouveaux chiffres) de le faire?

Jeremy Powell
la source
Peut gnutls-cli- être ?
Grawity
Après le changement de titre, cette question ne demande pas vraiment un logiciel-rec. Voter pour rouvrir.
Bob le
@ fix1234 Si cela vous rend plus heureux, j'ai supprimé toute occurrence du mot "outil". La question fondamentale est de savoir comment accomplir une tâche spécifique de toute façon. c'est une reformulation mineure et loin de questions plus "ouvertes" de type "liste de logiciels".
Bob le
@Bob: Je suis extatique. :-) Voter pour rouvrir.
fixer1234

Réponses:

232

J'ai écrit un script bash pour tester les suites de chiffrement. Il obtient une liste des suites de chiffrement prises en charge auprès d'OpenSSL et essaie de se connecter à l'aide de chacune d'entre elles. Si la poignée de main est réussie, elle est imprimée YES. Si la négociation échoue, il est imprimé NO, suivi du texte d'erreur 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

Voici un exemple de sortie montrant 3 chiffrements non pris en charge et 1 chiffrement pris en charge:

[@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: Ajoutez de la flexibilité car l'hôte et le port sont fournis comme paramètres du script

indiv
la source
7
openssl 1.0 a besoin d'un changement: if [[ "$result" =~ "Cipher :" ]] ; thenau lieu de if [[ "$result" =~ "Cipher is " ]] ; thentester également SSL2 et la renégociation sécurisée:echo -n Testing ssl2... result=$(echo -n | openssl s_client -ssl2 -connect $SERVER 2>&1) if [[ "$result" =~ "Cipher :" ]] ; then echo supported. INSECURE! else echo no support, OK fi echo -n Testing SSL secure renegotiation... echo -n "" | openssl s_client -connect $SERVER 2>&1 | grep 'Secure Renegotiation'
Hubert Kario le
9
Il existe un autre script shell très sophistiqué qui utilise sslscan et openssl: TLSSLed
Robert
2
J'ai répertorié ci-dessous un autre script nécessitant uniquement OpenSSL appelé CipherScan
Olivier - interfaSys le
1
Notez que ce script ne vous indiquera probablement pas si un serveur prend en charge les suites de chiffrement non prises en charge par OpenSSL.
sampablokuper
2
La suggestion de @Robert pour TLSSLed était fantastique. Il a été mis à jour à 1.3 et a beaucoup plus de fonctionnalités. J'utilise pour les tests de sécurité et je dois dire que je suis impressionné.
John Yeary
162

Nmap avec ssl-enum-ciphers

Il n’existe pas de moyen plus rapide ni meilleur d’obtenir une liste des chiffrements disponibles à partir d’un service réseau. De plus, nmap fournira une évaluation de force forte, faible ou inconnue pour chaque chiffre disponible.

Tout d’abord, téléchargez le script nmap ssl-enum-ciphers.nse ( explication ici ). Ensuite, à partir du même répertoire que le script, exécutez nmap comme suit:

Lister les chiffrements supportés par un serveur HTTP

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

Lister les chiffrements 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
Clint Pachl
la source
2
Est-il possible d'utiliser ce script sur IMAP avec STARTTLS? STARTTLS sur SMTP semble fonctionner, mais sur IMAP, le script ne semble même pas être exécuté.
Giel
Un couple de choses: vous pouvez exécuter le script dans votre distribution nmap, plutôt que celui que vous avez téléchargé. Vérifiez en renommant le vôtre. Vérifiez ensuite la "règle de port" qui, dans certaines versions, recherche les numéros de port les plus utilisés. Remplacer parportrule = function() \n return true \n end
slim
... et il faudrait du piratage pour travailler avec IMAP STARTTLS, FTPS, AUTH TLSetc., mais c'est possible.
slim
1
Un inconvénient est que les scripts plus anciens, qui peuvent être inclus dans votre distribution / package, répertorient les chiffrements par ordre alphabétique, et non par ordre préféré du serveur (ou du client). Voir le commentaire ci-dessus de @slim
Clint Pachl
3
Au cours des deux années écoulées depuis l'écriture de cette réponse, Nmap a ajouté la prise en charge de STARTTLS via FTP, NNTP, IMAP, LDAP, POP3, PostgreSQL, SMTP, XMPP, VNC et MS SQL, ainsi que de nombreuses améliorations allant au-delà de la simple liste des chiffrements pris en charge. .
bonsaïiviking
104

Existe-t-il un outil permettant de tester les suites de chiffrement SSL / TLS proposées par un site Web particulier?

Oui, vous pouvez utiliser l'outil en ligne sur le site Web de SSL Labs pour interroger la base de données publique du serveur SSL.

Voici un extrait d'information qu'il fournit:

texte alternatif

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

Kez
la source
C'est exactement ce que je cherchais! Merci beaucoup!
Jeremy Powell
11
Malheureusement, il ne prend en charge que HTTPS sur le port standard, vous ne pouvez pas l'utiliser pour vérifier les protocoles POP3S, IMAPS ou IMAP avec TLS
Hubert Kario le
1
Et s'il ne prend en charge que HTTPS, il manque même de support pour SNI.
Gurken Papst
12
Et bien que ce soit très pratique pour les sites destinés au public, vous ne pouvez pas l'utiliser pour les sites situés sur des réseaux isolés d'Internet.
Iszi
53

sslscan est un joli petit utilitaire.

Il teste la connexion avec TLS et SSL (le script de génération peut également être lié à sa propre copie d'OpenSSL afin que les versions SSL obsolètes soient également vérifiées) et des rapports sur les suites de chiffrement et le certificat du serveur.

Exemple de sortie pour google.com(réduit 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
indiv
la source
1
yum install sslscanfonctionne sur CentOS 6.
un codeur
1
sudo dnf install sslscansur Fedora 22 aussi.
Zayne S Halsall le
2
brew install sslscansur OSX
Xiao
sudo apt-get install sslscansur Ubuntu (12.04 - donc toutes les versions ultérieures devraient bien se passer).
Balu
3
Mise à jour: il convient de noter que la version officielle de sslscan trouvée dans les dépôts Debian et Ubuntu (actuellement la version 1.8.2 de 2009) ne prend pas en charge TLS v1.1 et 1.2, voir bugs.launchpad.net/ubuntu/+source/sslscan / + bug / 1372741 . Il faut donc utiliser la version sur GitHub à laquelle l'OP est lié.
Balu
15

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 ya un an et qui peut également identifier les problèmes liés aux chiffreurs d’échange de clés. https://github.com/jvehent/cipherscan

Si vous voulez mon fork qui supporte SNI et FreeBSD, l’URL est https://github.com/oparoz/cipherscan

C'est un script qui appelle openssl s_clientet prend en charge l'utilisation de votre propre fichier binaire OpenSSL afin que vous puissiez tester les fonctionnalités à venir ou les nouveaux chiffrements (chacha20 + poly1305 par exemple).

Il vous permet également de vous connecter à n’importe quel port et d’utiliser 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 cela à partir d'autres scripts.

Olivier - interfaSys
la source
"Config big-SSLv3 non pris en charge, la connexion a échoué"
un codeur
8

Après un peu de recherche sur Google, j'ai trouvé ce test pour SSL-TLS (OWASP-CM-001) :

Le scanner nmap , via l’option d’analyse «–sV», est capable d’identifier les services SSL. Les scanners de vulnérabilité, en plus de la découverte de service, peuvent inclure des vérifications sur les chiffrements faibles (par exemple, le scanneur Nessus a la capacité de vérifier les services SSL sur des ports arbitraires et signalera les chiffrements faibles).

et aussi: Foundstone SSL Digger est un outil permettant d'évaluer la puissance des serveurs SSL en testant les chiffrements pris en charge. On sait que certains de ces chiffrements sont peu sûrs.

fluxtendu
la source
2

SSLScan est génial; Un nouvel outil, SSLDiagnos, fonctionne pour Windows. Vous pouvez également écrire un script à l’aide du fichier openssl s_client.

Dwayne
la source
2

Le script ssl-enum-ciphers de Nmap peut répertorier les chiffrements et les versions SSL / TLS pris en charge, ainsi que les compresseurs pris en charge.

bonsaïivisme
la source
1
Votre réponse a été plus tôt, mais de Clint Pachl réponse explique ssl-enum-ciphersbeaucoup plus complète.
sampablokuper
2

Si vous voulez une belle sortie grepable (et un support pour vérifier toutes les versions de SSL / TLS)

Utilisation: ./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";
hackajar
la source
Vous êtes performant openssl ciphers -tls1.1et openssl ciphers -tls1.2pourtant ces paramètres ne semblent pas exister ... Il n'y en a que -tls1(du moins sur les plateformes que j'ai essayées).
Marki
(Il semble y avoir des options supplémentaires sous la forme de tls1_1et tls1_2mais elles ne sont montrées que dans la version principale d'OpenSL et même pas dans la 1.0.2 ....)
Marki
Notez que ce script ne vous indiquera probablement pas si un serveur prend en charge les suites de chiffrement non prises en charge par OpenSSL.
sampablokuper
2

Pentesterscripting.com propose un petit script qui utilise SSLScan et OpenSSL pour vérifier:

  • SSL v2;
  • Costumes de chiffrement de semaine;
  • MD5; et
  • Vulnérabilité de renégociation TLS

http://www.pentesterscripting.com/discovery/ssl_tests (via Internet Archive Wayback Machine )

Dupliqué ici pour l'avenir, 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

Utilisation: ./ssltest.sh HOST PORT

Pi3cH
la source
2

Sur la base de la réponse de @ indiv et de sa suggestion de l'afficher comme sa propre réponse, je fournis ma version modifiée du script de @ indiv. Vous pouvez fournir un hôte en tant que premier argument et il produira les mêmes résultats que le script d'origine, 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
insanisant
la source
2

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

Si vous souhaitez déterminer toutes les suites prises en charge par un serveur particulier, commencez par appeler openssl ciphers ALLpour obtenir une liste de toutes les suites prises en charge par votre version d'OpenSSL. Puis soumettez-les au serveur un par un pour les tester individuellement. Je ne suggère pas que vous le fassiez manuellement; C'est une situation dans laquelle un peu d'automatisation va un long chemin. En fait, il s’agit d’une situation dans laquelle il pourrait être approprié de rechercher un bon outil .

Il y a toutefois un inconvénient à tester de cette façon. Vous pouvez uniquement tester les suites prises en charge par OpenSSL. ...

Aucune bibliothèque SSL / TLS ne prend en charge toutes les suites de chiffrement , ce qui rend les tests complets difficiles. Pour SSL Labs, j’ai eu recours à une poignée de main partielle à cette fin, avec un client personnalisé prétendant prendre en charge des suites arbitraires . En réalité, il ne peut même pas négocier une seule suite, mais il suffit de proposer de négocier pour que les serveurs puissent vous dire s'ils prennent en charge une suite ou non. Non seulement vous pouvez tester toutes les suites de cette façon, mais vous pouvez également le faire de manière très efficace.

(Mon emphase.)

Le SSLTest de Stephen Bradshaw est un outil que je n'ai pas vu mentionné dans d'autres réponses. Il vise notamment à comparer "les chiffrements et les protocoles détectés aux normes de conformité telles que DSD ISM et PCI-DSS".

Alors, essayez ceci ou l’un des outils mentionnés dans les autres réponses, ou construisez le vôtre et envisagez d’utiliser l’approche de Ristić sur les poignées de main partielles.

sampablokuper
la source
1

J'ai écrit un outil qui fait exactement cela. Il s'appelle tlsenum et 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 contre twitter.com.

Cela ressemble à ce que fait SSL Lab, mais je trouve qu’avoir un outil de ligne de commande que vous pouvez automatiser et analyser est bien plus utile.

Ayrx
la source
1

SSLyze, à l’origine sur https://github.com/iSECPartners/sslyze , se trouve maintenant sur https://github.com/nabla-c0d3/sslyze . Cela a été mentionné dans une autre réponse , mais sans beaucoup de détails.

SSLyze est basé sur Python et fonctionne sous Linux / Mac / Windows à partir de la ligne de commande. Il utilise OpenSSL, et sous Windows, il est livré avec une copie fournie d’OpenSSL.

Répertorie les protocoles, les suites de chiffrement et les détails clés, ainsi que des tests pour détecter certaines vulnérabilités courantes. Il est possible d'activer ou de désactiver certaines vérifications, d'obtenir plus de données ou d'accélérer l'analyse.

CBHacking
la source
0

La seule chose que vous puissiez faire est de toutes les essayer, une à la fois, et de voir celles qui sont acceptées. Je ne suis pas au courant d'un outil pour ce faire, même s'il ne devrait pas être difficile d'en combiner un à partir d'outils de script et openssl s_client.

Tandis que le client annonce les suites de chiffrement qu’il acceptera, le serveur en choisit un et l’utilise ou échoue la connexion s’il ne trouve rien qu’il aime.

James K Polk
la source
Oh oui ... pour une raison quelconque, je pensais que c'était l'inverse. Peut-être que je peux trouver un outil pré-pavé ... :)
Jeremy Powell
0

Toutes ces réponses sont bonnes. Une partie de la réponse pourrait expliquer pourquoi nous avons besoin d’un outil pour découvrir une liste de serveurs et non pas demander directement à TLS que ce serveur donne toutes ses suites de chiffrement prises en charge, comme le fait le client TLS lorsqu’il se connecte à un serveur.

La réponse est que le serveur n’envoie jamais de liste , il suffit de sélectionner dans la liste de chiffrement du client le chiffrement qu’il souhaite utiliser, c’est ainsi que 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 chiffrements pour pouvoir trouver ceux qui sont pris en charge par le serveur et pour cela faire au moins une nouvelle poignée de main de démarrage (ClientHello) pour chaque suite de chiffrement.

Philippe Hardy
la source
0

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

C'est un script Perl qui fait fondamentalement ce que le script shell de hackajar fait, mais plus sophistiqué.

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

Par défaut, il ne prend AUTH SSLen charge que le FTP, mais une simple recherche et remplacement peut résoudre ce problème. En prime, il prétend également prendre en charge SMTP avec STARTTLSet RDP.

Daniel B
la source
0

TestSSLServer est une solution purement Java. Avantages:

  • il fonctionne très bas niveau, uniquement sur des sockets simples, il est donc indépendant des chiffrements indisponibles possibles de JDK ou d'OpenSSL .

  • il ne nécessite aucun port supplémentaire (comme ICMP pour le ping) pour être ouvert

  • ça marche avec les certificats clients présents

Désavantages:

  • à partir de 2016, la liste des chiffres pourrait être obsolète (bien que je ne sois pas un expert ici pour en juger)

Mon expérience personnelle: avec un serveur restreint n’ayant qu’un seul port HTTPS ouvert (aucun autre port), des certificats clients requis et iptables étant actif, il était toujours possible de répertorier les chiffrements disponibles, alors que les solutions les mieux choisies ne l’étaient pas (j’étais essayer un petit script shell, SSL Labs, NMap, sslscan)

mstrap
la source