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

Nmap mit ssl-Enum-Chiffren

Es gibt keine bessere oder schnellere Möglichkeit, eine Liste verfügbarer Chiffren von einem Netzwerkdienst abzurufen. Außerdem liefert nmap für jede verfügbare Chiffre eine Stärke von stark, schwach oder unbekannt.

Laden Sie zuerst die SSL-Enum-Chiffren herunter.nse nmap script (Erklärung hier ). Führen Sie dann aus demselben Verzeichnis wie das Skript nmap wie folgt aus:

Listen Sie Chiffren auf, die von einem HTTP unterstützt werden server

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

Listen Sie Chiffren auf, die von einem IMAP-Server unterstützt werden

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

Hier ist ein Ausschnitt der Ausgabe von 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, das testen kann, was SSL/TLS cipher suites ein bestimmtes die website bietet?

Ja, Sie könnten das Online-Tool auf SSL Labs' website zum Abfragen der öffentlichen SSL-Serverdatenbank.

Hier ist ein Ausschnitt von 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 eine Verbindung zu einer eigenen Kopie von OpenSSL herstellen, sodass auch veraltete SSL-Versionen überprüft werden) und berichtet über die Verschlüsselungssuiten und das Zertifikat des Servers.

Beispielausgabe für google.com (zur Lesbarkeit abgeschnitten):

$ 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 ein so großartiger Referenzthread für SSL-Scan-Tools ist, werde ich CipherScan auflisten, der vor einem Jahr erstellt wurde und auch Probleme mit Schlüsselaustauschziffern identifizieren kann. https://github.com/jvehent/cipherscan

Wenn Sie wollen meine Gabel, die unterstützt SNI und FreeBSD ist, wird der URL https://github.com/oparoz/cipherscan

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

Damit können Sie auch eine Verbindung zu einem beliebigen Port herstellen und starttlss 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 dies von anderen Skripten aus aufrufen.

Https://github.com/iSECPartners/sslyze

Dieser ist Python-basiert und funktioniert unter Linux/Mac / Windows über die Befehlszeile.

Nach ein wenig Googeln fand ich dieses Testen auf SSL-TLS (OWASP-CM-001):

Der Scanner nmap kann über die Scanoption" - sV " SSL-Dienste identifizieren. Schwachstellenscanner können neben der Diensterkennung auch Prüfungen gegen schwache Chiffren umfassen (z. B. kann der Nessus Scanner SSL-Dienste an beliebigen Ports überprüfen und schwache Chiffren melden).

Und auch: Foundstone SSL Digger ist ein Tool, um die Stärke von SSL-Servern durch Testen der unterstützten Chiffren zu beurteilen. Einige dieser Chiffren sind bekanntermaßen unsicher.

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

Diese Antwort fasst am besten gegebenen Antworten sofar und argumentiert, warum eine Alternative zu wählen (oder nicht!).

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

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Sucht nach bekannten Schwachstellen
• In sich geschlossen (keine Installation erforderlich)
• Unterstützt 370 Chiffren (ab Version 3.1) einschließlich veralteter Chiffren (nicht in neueren OpenSSL-Versionen enthalten)
• Erzeugt maschinenlesbare Ergebnisse (CSV und JSON)
• (parallelisierte) Stapelverarbeitung
• Langsam

Vielleicht der wichtigste Vorteil testssl.sh über die folgenden Alternativen ist die Verwendung einer Reihe von Binärdateien, die für Schwachstellentests zugeschnitten sind (lesen Sie die Erklärung des Entwicklers hier).

2. cipherscan

• CLI (python)
• Kein TLSv1.3
• In sich geschlossen
• Begrenzte Cipher Suites (fest codiert)
• Erzeugt maschinenlesbare Ergebnisse (JSON)
• Schnell

3. nmap - ssl-enum-ciphers

• CLI (nmap Skript)
• Kein TLSv1.3
• In sich geschlossen
• Begrenzte Cipher Suites (fest codiert)
• Sucht nach bekannten Schwachstellen
• Keine maschinenlesbaren Ergebnisse

Für eine vollständige übersicht der verfügbaren tools finden Sie unter sslLabs-Assessment-Tools.

SSLScan ist großartig; ein neues Tool Ssldiagnose funktioniert für Windows, oder Sie können einfach ein Skript mit dem openssl s_client schreiben.

Wenn Sie möchten ein schönes grepable Ausgabe (und die Unterstützung für die Kontrolle 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";

Es gibt ein nettes kleines Skript bei pentesterscripting.com um sowohl SSLScan als auch OpenSSL zu verwenden, um Folgendes zu überprüfen:

• SSL v2;
• Woche Chiffren Anzüge;
• MD5; und
• TLS-Schwachstelle bei Neuverhandlungen

Http://www.pentesterscripting.com/discovery/ssl_tests (über das Internet-Archiv Wayback Machine)

Dupliziert hier für Futureproofing, da die Hauptseite 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

Verwendung:. /ssltest.sh GASTGEBER PORT -

Basierend auf @indivs Antwort und dem Vorschlag, es als eigene Antwort zu posten, stelle ich meine optimierte Version von @indivs Skript bereit. Sie können einen Host als erstes Argument angeben, der die gleichen Ergebnisse wie das ursprüngliche Skript ausgibt, jedoch etwas formatierter ist:

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

Das (kostenlose) OpenSSL-Kochbuch von Ivan Ristić, der das Online-Tool SSL Labs entwickelt hat, das in der Antwort von Kez angegeben ist, besagt:

Wenn Sie alle Suiten ermitteln möchten, die von einem bestimmten Server unterstützt werden, rufen Sie zunächst openssl ciphers ALL auf, um eine Liste aller Suiten abzurufen unterstützt von Ihrer version von OpenSSL. Dann senden Sie sie an den Server eins nach dem anderen, um sie einzeln zu testen. Ich schlage nicht vor, dass Sie tun dies manuell; Dies ist eine Situation, in der ein wenig automatisierung geht ein langer Weg. In der Tat ist dies eine situation, in welcher auf der Suche nach einer gutes Werkzeug könnte angemessen sein.

Das Testen hat einen Nachteil auf diese Weise jedoch. Sie können nur die Suiten testen, die OpenSSL unterstützt. ...

Keine einzige SSL/TLS-Bibliothek unterstützt alle cipher suites, und das macht umfassende Prüfung schwierig. Für SSL Labs habe ich verwendet teilweise Handshakes für diesen Zweck, mit einem benutzerdefinierten Client, der gibt vor, beliebige Suiten zu unterstützen. Es kann eigentlich nicht einmal verhandeln eine einzelne Suite, aber nur vorschlagen zu verhandeln ist genug für Server um Ihnen zu sagen, ob sie eine Suite unterstützen oder nicht. Sie können nicht nur alle testen die Suiten auf diese Weise, aber Sie können es auch sehr effizient tun.

(Meine Betonung.)

Ein Werkzeug, das ich in anderen Antworten nicht erwähnt habe, ist Stephen Bradshaws SSLTest, der unter anderem "die erkannten Chiffren und protokolle gegen Compliance-Standards wie DSD ISM und PCI-DSS."

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

Ich habe ein tool geschrieben, das genau das tut dies. Es heißt tlsenum und ist auf GitHub verfügbar.

[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 Werkzeugs gegen twitter.com.

Es ähnelt dem von SSL Lab, aber ich finde, dass es viel nützlicher ist, ein Befehlszeilentool zu haben, das Sie automatisieren und analysieren können.

SSLyze, ursprünglich bei https://github.com/iSECPartners/sslyze, ist jetzt bei https://github.com/nabla-c0d3/sslyze. Es wurde in eine andere Antwort erwähnt, aber ohne viel Detail.

SSLyze ist Python-basiert und funktioniert unter Linux/Mac/Windows über die Befehlszeile. Es verwendet OpenSSL und unter Windows wird eine gebündelte Kopie von OpenSSL mitgeliefert.

Listet Protokolle, Verschlüsselungssuiten und wichtige Details sowie Tests für einige häufige Schwachstellen auf. Es ist möglich zu aktivieren oder deaktivieren Sie bestimmte Prüfungen, um mehr Daten zu erhalten oder den Scan zu beschleunigen.

Das einzige, was du tun kannst, ist, sie alle einzeln auszuprobieren und zu sehen, welche akzeptiert werden. Ich kenne kein Werkzeug, um dies zu tun, obwohl es nicht schwer sein sollte, eines aus Skriptwerkzeugen und openssl s_client zusammenzupflastern.

Während der Client wirbt, welche Chiffren er akzeptiert, wählt der Server einfach einen aus und verwendet ihn oder schlägt die Verbindung fehl, wenn er nichts findet, was ihm gefällt.

All diese Antworten sind in Ordnung. Ein Teil der Antwort könnte erklären, warum wir ein Tool benötigen, um die Liste des Servers zu ermitteln und nicht direkt in TLS nachzufragen, dass der Server alle unterstützten Verschlüsselungssuiten bereitstellt, genau wie es der TLS-Client tut, wenn er eine Verbindung zu einem Server herstellt.

Antwort ist, dass Server sendet keine Liste immer, es wählt nur in Client-Chiffre-Liste die Chiffre, die es verwenden möchte, dies ist die Art und Weise SSL / TLS-Protokoll geschrieben wird : 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 finden zu können, und dafür mindestens einen neuen Starthandshake (ClientHello) für jede Verschlüsselungssuite ausführen.

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

Es ist ein Perl-Skript, das im Grunde das tut, was Hackajars Shell-Skript tut, nur ausgefeilter.

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

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

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

• Es funktioniert sehr Low-Level, nur auf einfachen Sockets, also ist es unabhängig von möglichen nicht verfügbaren Chiffren von JDK oder OpenSSL .

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

• Es funktioniert mit Client-Zertifikaten vorhanden

Nachteile:

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

Meine persönliche Erfahrung: Angesichts eines eng geschnürten Servers mit nur einem einzigen offenen HTTPS-Port (kein anderer Port), Clientzertifikaten und aktiven iptables war es immer noch möglich, verfügbare Chiffren aufzulisten, während top-bewertete Lösungen dies nicht waren (ich habe es versucht kleines Shell-Skript, SSL Labs, NMap, sslscan)