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

Question

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 dump hexagonal 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.

Mettre à 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 une manière plus simple et plus pérenne (par exemple, de nouveaux chiffres)

indiv · Accepted Answer

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’elles. Si la poignée de main est réussie, il imprime YES. Si la négociation échoue, il imprime 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

Clint Pachl · Answer

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.

Commencez par télécharger le script ssl-enum-ciphers.nse nmap ( 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

Kez · Answer

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 SSL Labs 'pour interroger la base de données publique du serveur SSL.

Voici un extrait d'information qu'il fournit:

alt text

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

indiv · Answer

sslscan est un joli petit utilitaire.

Il teste la connexion avec TLS et SSL (et le script de construction peut ê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

Olivier - interfaSys · Answer

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 chiffrements 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_client et 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.

Scott · Answer

https://github.com/iSECPartners/sslyze

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

fluxtendu · Answer

Après quelques recherches sur Google, j'ai trouvé ceci Test de SSL-TLS (OWASP-CM-001) :

Le nmap scanner, 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 contre 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 également: Foundstone SSL Digger est un outil qui permet 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.

Dirk · Answer

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

bonsaiviking · Answer

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

insaner · Answer

Sur la base de réponse de @ indiv et de la 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

sampablokuper · Answer

Le (gratuit) OpenSSL Cookbook par Ivan Ristić, qui a développé 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 ALL pour obtenir la 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 chercher un bon outil pourrait être approprié .

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 unique 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 fait, 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.)

Un des outils que je n'ai pas vu mentionné dans d'autres réponses est le SSLTest de Stephen Bradshaw, qui, entre autres choses, vise à 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.

Pi3cH · Answer

Il y a un joli petit script sur pentesterscripting.com pour utiliser 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

hackajar · Answer

Si vous voulez une sortie Nice 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";

Dwayne · Answer

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

Ayrx · Answer

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.

mstrap · Answer

TestSSLServer est une solution purement Java. Avantages:

cela fonctionne très bas niveau, juste sur des sockets simples, donc c'est independent des chiffrements indisponibles possibles de JDK ou 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 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 en mesure de répertorier les chiffrements disponibles, alors que les solutions les plus populaires essayer un petit script shell, SSL Labs, NMap, sslscan)

CBHacking · Answer

SSLyze, à l’origine sur https://github.com/iSECPartners/sslyze , est maintenant sur https://github.com/nabla-c0d3/sslyze . Cela a été mentionné dans une autre réponse , mais sans trop 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.

Daniel B · Answer

En cherchant quelque chose qui 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 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 supporte que AUTH SSL sur FTP, mais une simple recherche et remplacement peut résoudre ce problème. En prime, il prétend également prendre en charge SMTP avec STARTTLS et RDP.

philippe lhardy · Answer

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 une 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 faire au moins une nouvelle poignée de main de démarrage (ClientHello) pour chaque suite de chiffrement.

James K Polk · Answer

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 le faire, même s'il ne devrait pas être difficile d'en combiner un à partir d'outils de script et de 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.