Wie liste ich die SSL/TLS-Verschlüsselungssuites auf, die eine bestimmte Website anbietet?

Ich habe ein Bash-Skript geschrieben, um Chiffrier-Suiten zu testen. Es holt sich eine Liste der unterstützten Verschlüsselungs-Suites von OpenSSL und versucht, mit jeder einzelnen eine Verbindung herzustellen. Wenn der Handshake erfolgreich ist, gibt es YES aus. Wenn der Handshake nicht erfolgreich ist, druckt es NO, gefolgt vom OpenSSL-Fehlertext.

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

Hier ist eine Beispielausgabe, die 3 nicht unterstützte Chiffren und 1 unterstützte Chiffre zeigt:

[@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: Flexibilität hinzufügen, da Host und Port als Parameter dem Skript zur Verfügung gestellt werden

Nmap with ssl-enum-ciphers

Es gibt keinen besseren oder schnelleren Weg, um eine Liste der verfügbaren Chiffren von einem Netzdienst zu erhalten. Außerdem liefert nmap eine Stärkebewertung von stark, schwach oder unbekannt für jede verfügbare Chiffre.

Laden Sie zuerst das ssl-enum-ciphers.nse nmap-Skript Erklärung hier ) herunter. Führen Sie dann nmap aus dem gleichen Verzeichnis wie das Skript wie folgt aus:

Listen Sie die von einem HTTP-Server unterstützten Chiffren auf

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

Listen Sie die von einem IMAP-Server unterstützten Chiffren auf

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

Hier ist ein Ausschnitt der Ausgabe von einem Dovecot-IMAP-Server:

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

Gibt es ein Tool, mit dem getestet werden kann, welche SSL/TLS-Verschlüsselungspakete eine bestimmte Website anbietet?

Ja, Sie könnten das Online-Tool auf der Website SSL Labs ’ verwenden, um die Public SSL Server Database abzufragen.

Hier ist ein Ausschnitt der Informationen, die es bietet:

(Screenshot aus den Ergebnissen von google.com)

sslscan ist ein nettes kleines Dienstprogramm.

Es testet die Verbindung mit TLS und SSL (und das Build-Skript kann mit seiner eigenen Kopie von OpenSSL verlinken, so dass auch veraltete SSL-Versionen überprüft werden) und berichtet über die Cipher-Suites und das Zertifikat des Servers.

Beispielausgabe für google.com (auf Lesbarkeit getrimmt):

$ 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

Da dies so ein großartiger Referenz-Thread für SSL-Scan-Tools ist, werde ich CipherScan auflisten, der vor einem Jahr erstellt wurde und auch Probleme mit Schlüsselaustausch-Chiffren identifizieren kann https://github.com/jvehent/cipherscan

Wenn Sie meinen Fork wollen, der SNI und FreeBSD unterstützt, die URL i https://github. com/oparoz/cipherscan

Es handelt sich um ein Skript, das openssl s_client aufruft und die Verwendung Ihrer eigenen OpenSSL-Binärdatei unterstützt, so dass Sie kommende Funktionen oder neue Chiffren testen können (chacha20+poly1305 als Beispiel).

Es erlaubt Ihnen auch, sich mit jedem beliebigen Port zu verbinden und starttlss zu verwenden.

Hier ist eine typische Ausgabe

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

Und hier ist eine Liste von Optionen

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

Die Json-Ausgabe ist nützlich, wenn Sie diese von anderen Skripten aus aufrufen.

https://github.com/iSECPartners/sslyze

Dieser hier ist Python-basiert, funktioniert unter Linux/Mac/Windows von der Kommandozeile aus.

Nach einigem Googeln fand ich dies Testing for SSL-TLS (OWASP-CM-001) :

Der Scanner nmap ist über die Scan-Option “-sV” in der Lage, SSL-Dienste zu identifizieren. Schwachstellen-Scanner können neben der Diensterkennung auch Prüfungen gegen schwache Chiffren umfassen (z.B. kann der Nessus-Scanner SSL-Dienste auf beliebigen Ports prüfen und wird schwache Chiffren melden).

und auch: Foundstone SSL Digger ist ein Tool zur Bewertung der Stärke von SSL-Servern durch Testen der unterstützten Chiffren. Einige dieser Chiffren sind als unsicher bekannt.

Ich verwende für die meisten SSL-Tests die Datei testssl.sh (siehe https://testssl.sh / devel version @ https://github.com/drwetter/testssl.sh . Es testet auf Schwachstellen, Chiffren, Protokolle usw.

Wenn Sie eine schöne grepable Ausgabe wünschen (und Unterstützung für die Überprüfung aller SSL/TLS-Versionen)

Verwendung: ./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 ist großartig; ein neues Tool SSLDiagnos funktioniert für Windows, oder Sie können einfach ein Skript mit dem openssl s_client schreiben.

Basierend auf @indiv’s answer und dem Vorschlag, es als eigene Antwort zu posten, stelle ich meine überarbeitete Version von @indiv’s Skript zur Verfügung. Sie können einen Host als erstes Argument angeben, der die gleichen Ergebnisse wie das Originalskript ausgibt, nur etwas formatierter:

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

Es gibt ein nettes kleines Skript unter pentesterscripting.com, das sowohl SSLScan als auch OpenSSL verwendet, um zu prüfen auf:

• SSL v2;
• Week chiphers suits;
• MD5; und
• TLS Neuverhandlungs-Schwachstelle http://www. pentesterscripting.com/discovery/ssl_tests (über das Internet-Archiv Wayback Machine )

Hier zur Zukunftssicherung dupliziert, da die Hauptsite jetzt tot ist:

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

Nutzung: ./ssltest.sh HOST PORT

Das Skript ssl-enum-ciphers von Nmap kann die unterstützten Chiffren und SSL/TLS-Versionen sowie die unterstützten Kompressoren auflisten.

Im (kostenlosen) OpenSSL Cookbook von Ivan Ristić, der das in Kez’ Antwort erwähnte Online-Tool SSL Labs entwickelt hat, heißt es:

Wenn Sie alle von einem bestimmten Server unterstützten Suites ermitteln möchten, beginnen Sie mit dem Aufruf von openssl ciphers ALL, um eine Liste aller Suites zu erhalten, die von Ihrer Version von OpenSSL unterstützt werden. Schicken Sie sie dann nacheinander an den Server, um sie einzeln zu testen. Ich schlage nicht vor, dass Sie dies manuell tun; dies ist eine Situation, in der ein wenig Automatisierung einen langen Weg geht. Tatsächlich ist dies eine Situation, in der es angebracht sein könnte, sich nach einem guten Werkzeug umzuschauen.

Es hat jedoch einen Nachteil, auf diese Weise zu testen. Sie können nur die Suites testen, die OpenSSL unterstützt. …

Keine einzelne SSL/TLS-Bibliothek unterstützt alle Chiffrier-Suites , und das macht umfassende Tests schwierig. Für SSL Labs habe ich zu diesem Zweck auf partielle Handshakes zurückgegriffen, mit einem benutzerdefinierten Client, der vorgibt, beliebige Suiten zu unterstützen. Tatsächlich kann er nicht einmal eine einzige Suite aushandeln, aber allein der Vorschlag, zu verhandeln, reicht den Servern aus, um Ihnen mitzuteilen, ob sie eine Suite unterstützen oder nicht. Auf diese Weise kann man nicht nur alle Suites testen, sondern auch sehr effizient.

(Meine Hervorhebung.)

Ein Werkzeug, das ich in anderen Antworten noch nicht gesehen habe, ist Stephen Bradshaws SSLTest , das unter anderem darauf abzielt, “die erkannten Chiffren und Protokolle mit Konformitätsstandards wie DSD ISM und PCI-DSS zu vergleichen. ”

Probieren Sie also dieses oder eines der in den anderen Antworten erwähnten Tools aus, oder bauen Sie Ihr eigenes und ziehen Sie in Betracht, Ristić’s Ansatz des partiellen Handshakes zu verwenden.

Diese Antwort fasst die besten bisher gegebenen Antworten zusammen und argumentiert, warum eine Alternative gewählt werden sollte (oder auch nicht!)._

Um die beste Lösung zu finden, sollten wir zuerst antworten: “Warum wollen wir alle unterstützten Chiffren aufzählen? Hier liegt der Schwerpunkt auf dem Sicherheitsaspekt, d.h. herauszufinden, ob ein Server verwundbar ist oder nicht. Die nächste Frage, die es zu beantworten gilt, ist, ob die Ausgabe maschinenlesbar sein soll, z.B. um in einem Skript weiter verwendet zu werden, oder nicht.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Überprüft auf bekannte Schwachstellen
• In sich geschlossen (keine Installation erforderlich)
• Unterstützt 370 ciphers (ab Version 3.1) einschließlich veralteter Chiffren (nicht in neueren openSSL-Versionen enthalten)
• Produziert maschinenlesbare Ergebnisse (CSV und JSON)
• Unterstützt testssl.sh (ab Version cipherscan) einschließlich veralteter Chiffren (nicht in neueren openSSL-Versionen enthalten)
• Produziert maschinenlesbare Ergebnisse (CSV und JSON)
• (parallelisierte) Stapelverarbeitung
• Langsam

Der vielleicht wichtigste Vorteil von ssl-enum-ciphers gegenüber den folgenden Alternativen ist die Verwendung einer Reihe von Binärdateien, die auf Schwachstellenprüfungen zugeschnitten sind (lesen Sie die Erklärung des Entwicklers hier ).

2. nmap

• CLI (Python)
• Kein TLSv1.3
• In sich geschlossen
• Begrenzte Chiffrier-Suites (fest codiert)
• Produziert maschinenlesbare Ergebnisse (JSON)
• Schnell

3. nmap &007

• CLI (&007-Skript)
• Kein TLSv1.3
• Unabhängig
• Eingeschränkte Verschlüsselungssuites (fest kodiert)
• Überprüft auf bekannte Schwachstellen
• Keine maschinenlesbaren Ergebnisse

Für einen umfassenden Überblick über die verfügbaren Tools siehe [ sslLabs Assessment Tools ]&003.

SSLyze, ursprünglich unter https://github.com/iSECPartners/sslyze , ist jetzt unter https://github.com/nabla-c0d3/sslyze zu finden. Es wurde in einer anderen Antwort erwähnt, aber ohne viele Details.

SSLyze basiert auf Python und funktioniert unter Linux/Mac/Windows von der Kommandozeile aus. Es verwendet OpenSSL, und unter Windows wird es mit einer gebündelten Kopie von OpenSSL geliefert.

listet Protokolle, Cipher Suites und Schlüsseldetails auf, sowie Tests auf einige häufige Schwachstellen. Es ist möglich, bestimmte Prüfungen zu aktivieren oder zu deaktivieren, um mehr Daten zu erhalten oder den Scan zu beschleunigen.

Ich habe ein Tool geschrieben, das genau dies tut. Es heißt Tlsenum und ist verfügbar unter 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

Hier ist eine Beispielausgabe des Tools gegen twitter.com.

Es ähnelt dem, was SSL Lab’s macht, aber ich finde, dass ein Befehlszeilen-Tool, das man automatisieren und parsen kann, viel nützlicher ist.

Alle diese Antworten sind in Ordnung. Ein Teil der Antwort könnte erklären, warum wir ein Werkzeug brauchen, um die Liste der Server zu ermitteln und nicht direkt im TLS zu fragen, ob der Server alle seine unterstützten Verschlüsselungs-Suites zur Verfügung stellt, so wie es der TLS-Client tut, wenn er eine Verbindung zu einem Server herstellt.

Die Antwort ist, dass der Server niemals eine Liste sendet , er wählt einfach in der Verschlüsselungsliste des Clients die Verschlüsselung aus, die er verwenden möchte, so ist das SSL/TLS-Protokoll geschrieben : http://wiki. opensslfoundation.com/index.php/SSL_and_TLS_Protocols#Cipher_Suites

Deshalb muss der Client Chiffren aufzählen, um die vom Server unterstützten Chiffren zu finden und dafür mindestens einen neuen Start-Handshake (ClientHello) für jede Chiffren-Suite durchführen zu können.

Das Einzige, was Sie tun können, ist, sie alle auszuprobieren, eine nach der anderen, und zu sehen, welche davon akzeptiert werden. Mir ist kein Werkzeug dafür bekannt, obwohl es nicht schwer sein dürfte, eines aus Skripting-Tools und openssl s_client.

Während der Client dafür wirbt, welche Chiffren er akzeptiert, wählt der Server einfach eine aus und benutzt sie oder schlägt die Verbindung fehl, wenn er nichts findet, was ihm gefällt.

TestSSLServer ist eine rein Java-basierte Lösung. Vorteile:

• es arbeitet sehr low-level, nur auf einfachen Sockets, also unabhängig von möglicherweise nicht verfügbaren Chiffren aus JDK oder OpenSSL.

• es müssen keine zusätzlichen Ports (wie ICMP für Ping) geöffnet werden

• es funktioniert mit vorhandenen Client-Zertifikaten

Nachteile:

• ab 2016 könnte die Liste der Chiffren veraltet sein (obwohl ich hier kein Experte bin, um dies zu beurteilen)

Meine persönliche Erfahrung: Angesichts eines Servers mit engem Netzwerk und nur einem einzigen offenen HTTPS-Port (kein anderer Port), erforderlichen Client-Zertifikaten und aktiven iptables war er immer noch in der Lage, die verfügbaren Chiffren aufzulisten, während die von oben gewählten Lösungen nicht verfügbar waren (ich habe ein kleines Shell-Skript, SSL Labs, NMap, sslscan ausprobiert).

Auf der Suche nach etwas, das AUTH TLS auf FTP macht, bin ich auf dieses Tool gestoßen: ssl-cipher-suite-enum

Es ist ein Perl-Skript, das im Grunde das macht, was das Shell-Skript von Hackajar macht, nur ausgefeilter.

Es bietet auch eine grundlegende Auswertung der angebotenen Chiffren und Protokolle. Es ist ein wenig wie die Tools von SSL Labs, nur für den Heimgebrauch :)

Standardmäßig unterstützt es nur AUTH SSL auf FTP, aber ein einfaches Suchen und Ersetzen kann das beheben. Als Bonus behauptet es auch, SMTP mit STARTTLS und RDP zu unterstützen.