Jak mogę wyświetlić listę pakietów szyfrów SSL/TLS poszczególnych ofert internetowych?

Napisałem skrypt bash do testowania pakietów szyfrów. Otrzymuje on listę obsługiwanych pakietów szyfrów z OpenSSL i próbuje połączyć się za pomocą każdego z nich. Jeśli uścisk dłoni się powiedzie, drukuje YES. Jeśli handshake nie powiedzie się, wypisuje NO, a następnie tekst błędu 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

Oto przykładowe wyjście pokazujące 3 nieobsługiwane szyfry i 1 obsługiwany szyfr:

[@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: Dodaj elastyczność, ponieważ host i port są dostarczane jako parametr do skryptu.

Nmap z ssl-enum-ciphers

Nie ma lepszego lub szybszego sposobu na uzyskanie listy dostępnych szyfrów z usługi sieciowej. Plus, nmap dostarczy ocenę siły silnego, słabego lub nieznanego dla każdego dostępnego szyfru.

Najpierw pobierz skrypt ssl-enum-ciphers.nse nmap wyjaśnienie tutaj ). Następnie z tego samego katalogu co skrypt należy uruchomić nmap w następujący sposób:

List ciphers supported by an HTTP server

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

List ciphers supported by an IMAP server

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

Here is a snippet of output from a 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

Czy istnieje narzędzie, które może przetestować, jakie szyfry SSL/TLS oferuje dana strona internetowa?

Tak, można użyć narzędzia online na stronie SSL Labs ’, aby zapytać o Bazę Danych Publicznego Serwera SSL.

Oto fragment informacji, które dostarcza:

(zrzut ekranu z wyników google.com)

sslscan jest małym, ładnym narzędziem.

Testuje połączenia z TLS i SSL (a skrypt budujący może łączyć się z własną kopią OpenSSL, dzięki czemu sprawdzane są także przestarzałe wersje SSL) oraz raporty o pakietach szyfrujących i certyfikatach serwera.

Przykładowe wyjście dla google.com (przycięte dla czytelności):

$ 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

Ponieważ jest to taki świetny wątek referencyjny dla narzędzi do skanowania SSL, wymienię CipherScan, który został stworzony rok temu, a także mogę zidentyfikować problemy z kluczowymi szyframi wymiany https://github.com/jvehent/cipherscan

Jeśli chcesz mój widelec, który obsługuje SNI i FreeBSD, adres URL i https://github. com/oparoz/cipherscan

Jest to skrypt, który wywołuje openssl s_client i wspiera używanie własnego binarnego OpenSSL, dzięki czemu możesz przetestować nadchodzące funkcje lub nowe szyfry (chacha20+poly1305 na przykład).

Umożliwia także podłączenie do dowolnego portu i użycie starttlss.

Oto typowe wyjście

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

A oto lista opcji

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

Wyjście json jest przydatne, jeśli wywołujesz je z innych skryptów.

https://github.com/iSECPartners/sslyze

Ten jest oparty na Pythonie, działa w systemie Linux/Mac/Windows z linii poleceń.

Po małym googlingu znalazłem to Testowanie dla SSL-TLS (OWASP-CM-001) :

Skaner nmap , poprzez opcję skanowania “-sV”, jest w stanie zidentyfikować usługi SSL. Skaner Nessus ma możliwość sprawdzania usług SSL na dowolnych portach i będzie zgłaszał słabe szyfry).

i002 > Skaner nmap > Skaner [ nmap ]&003 ma możliwość sprawdzania usług SSL na dowolnych portach i będzie zgłaszał słabe szyfry: [ Foundstone SSL Digger ]&003 jest narzędziem do oceny wytrzymałości serwerów SSL poprzez testowanie obsługiwanych szyfrów. Niektóre z tych szyfrów są znane jako niepewne.

Używam do większości testów SSL testssl.sh (patrz https://testssl.sh / devel version @ https://github.com/drwetter/testssl.sh . Testuje on luki, szyfry, protokoły itp.

Jeśli chcesz mieć ładne grepable wyjście (i wsparcie dla sprawdzania wszystkich wersji SSL/TLS)

Użycie: ./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 jest świetny; nowe narzędzie SSLDiagnos działa dla Windows, lub możesz po prostu napisać skrypt używając openssl s_klienta.

Na podstawie [ odpowiedzi ] @indivu i sugestii, aby umieścić go jako swoją własną odpowiedź, dostarczam moją poprawioną wersję skryptu @indivu. Możesz podać hosta jako pierwszy argument, który da te same wyniki co oryginalny skrypt, ale nieco bardziej sformatowany:

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

Na stronie pentesterscripting.com znajduje się mały skrypt, który wykorzystuje zarówno SSLScan jak i OpenSSL do sprawdzenia:

• SSL v2;
• Week ciphers suit;
• MD5; oraz
• TLS Renegotiation vulnerability http://www. pentesterscripting.com/discovery/ssl_tests (przez Internetowe Archiwum Wayback Machine )

Duplikowane tutaj dla zabezpieczenia przed przyszłością, ponieważ główna strona jest już martwa:

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

Użytkowanie: ./ssltest.sh HOST PORT

Skrypt Nmapy ssl-enum-ciphers może zawierać listę obsługiwanych szyfrów i wersji SSL/TLS, a także obsługiwanych kompresorów.

The (free of charge) OpenSSL Cookbook by Ivan Ristić, who developed the SSL Labs online tool noted in Kez’s answer , states:

If you want to determine all suites supported by a particular server, start by invoking openssl ciphers ALL to obtain a list of all suites supported by your version of OpenSSL. Następnie wyślij je na serwer jeden po drugim, aby przetestować je indywidualnie. Nie sugeruję, abyś robił to ręcznie; jest to sytuacja, w której odrobina automatyzacji przechodzi długą drogę. W rzeczywistości jest to sytuacja, w której rozglądanie się za dobrym narzędziem może być odpowiednie.

Istnieje jednak wada testowania w ten sposób. Możesz testować tylko te pakiety, które OpenSSL obsługuje. …

Żadna pojedyncza biblioteka SSL/TLS nie obsługuje wszystkich pakietów szyfrujących , a to utrudnia kompleksowe testowanie. Dla SSL Labs, I uciekł się do korzystania z częściowych uścisków dłoni w tym celu, z niestandardowym klientem, który udaje, że obsługuje dowolne apartamenty. W rzeczywistości nie jest w stanie wynegocjować nawet jednego pakietu, ale samo zaproponowanie negocjacji wystarczy, aby serwery poinformowały cię, czy obsługują dany pakiet, czy nie. Możesz nie tylko przetestować wszystkie pakiety w ten sposób, ale także zrobić to bardzo sprawnie.

(Mój akcent.)

Jedno z narzędzi, którego nie widziałem w innych odpowiedziach to SSLTest Stephena Bradshaw'a, który, między innymi, ma na celu porównanie “wykrytych szyfrów i protokołów ze standardami zgodności, takimi jak DSD ISM i PCI-DSS. ”

Więc spróbuj tego lub jednego z narzędzi wymienionych w innych odpowiedziach, albo zbuduj swoje własne i rozważ zastosowanie podejścia Ristića polegającego na częściowym uścisku dłoni.

Ta odpowiedź podsumowuje najlepiej udzielone dotychczas odpowiedzi i argumentuje dlaczego wybrać alternatywę (lub nie!)._

• *

Aby znaleźć najlepsze rozwiązanie, powinniśmy najpierw odpowiedzieć “dlaczego chcemy wymienić wszystkie obsługiwane szyfry? Skupiamy się tutaj na aspekcie bezpieczeństwa, czyli na tym, czy serwer jest podatny na zagrożenia, czy też nie. Następnym pytaniem, na które należy odpowiedzieć jest, czy wyjście powinno być maszynowo czytelne, np. do dalszego wykorzystania w skrypcie, czy też nie.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Check for known vulnerabilities
• Self-contained (not installation needed)
• Supports 370 ciphers (as of version 3.1) including deprecated ciphers (not included in newer openSSL versions)
• Produces machine-readable results (CSV and JSON)
• (paralelizowane) przetwarzanie wsadowe
• Slow

Być może najważniejszą przewagą testssl.sh nad poniższymi alternatywami jest użycie zestawu binariów, które są dostosowane do testowania podatności (przeczytaj wyjaśnienie developera tutaj ).

2. cipherscan

• CLI (python)
• No TLSv1.3
• Self-contained
• Limited cipher suites (hard-coded)
• Produces machine-readable results (JSON)
• Fast

3. nmap ssl-enum-ciphers

• CLI (nmap script)
• No TLSv1.3
• Self-contained
• Limited cipher suites (hard-coded)
• Checks for known vulnerabilities

• No machine-readable results

Wyczerpujący przegląd dostępnych narzędzi zobacz sslLabs Assessment Tools .

SSLyze, pierwotnie pod adresem https://github.com/iSECPartners/sslyze , jest teraz pod adresem https://github.com/nabla-c0d3/sslyze . Zostało to wspomniane w inna odpowiedź , ale bez większych szczegółów.

SSLyze jest oparty na Pythonie i działa na Linuksie/Macu/Windows z linii poleceń. Używa OpenSSL, a na Windows dołączona jest do niego dołączona kopia OpenSSL.

Lists, cipher suites, and key details, plus testy na niektóre typowe luki. Możliwe jest włączenie lub wyłączenie poszczególnych kontroli, aby uzyskać więcej danych lub przyspieszyć skanowanie.

Napisałem narzędzie, które robi dokładnie to. Nazywa się tlsenum i jest dostępne na 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

Oto przykładowe wyjście narzędzia z twitter.com.

Jest podobne do tego, co robi laboratorium SSL, ale uważam, że posiadanie narzędzia z linii poleceń, które można zautomatyzować i przetworzyć jest znacznie bardziej użyteczne.

Wszystkie te odpowiedzi są w porządku. Jedna z części odpowiedzi mogłaby wyjaśnić, dlaczego potrzebujemy narzędzia do odkrywania listy serwerów, a nie pytać bezpośrednio w TLS, czy serwer podaje wszystkie obsługiwane przez siebie pakiety szyfrujące, tak jak robi to klient TLS, gdy łączy się z serwerem.

Odpowiedź jest taka, że server nigdy nie wysyła listy , po prostu wybiera na liście szyfrów klienta szyfr, którego chce użyć, tak jest napisany protokół SSL/TLS : http://wiki. opensslfoundation.com/index.php/SSL_oraz_TLS_Protocols#Cipher_Suites

Dlatego klient musi wymienić szyfry, aby móc znaleźć te obsługiwane przez serwer i w tym celu zrobić co najmniej jeden nowy startowy handshake (ClientHello) dla każdego pakietu szyfrów.

Jedyne, co możesz zrobić, to wypróbować je wszystkie, po kolei, i zobaczyć, które z nich są akceptowane. Nie znam narzędzia do tego, choć nie powinno być trudno wybrukować go razem z narzędzi skryptowych i openssl s_client.

Podczas gdy klient reklamuje, który szyfr przyjmie, serwer po prostu wybiera jeden i używa go lub zawiedzie połączenie, jeśli nie znajdzie niczego, co mu się podoba.

TestSSLServer jest rozwiązaniem czysto Java. Zalety:

• działa na bardzo niskim poziomie, tylko na zwykłych gniazdach, więc jest niezależny od możliwych niedostępnych szyfrów z JDK lub OpenSSL.

• nie wymaga otwierania żadnych dodatkowych portów (jak ICMP dla pingów)

• działa z obecnymi certyfikatami klienckimi

Wady:

• od 2016 roku lista szyfrów może być nieaktualna (choć nie jestem tu ekspertem, aby to ocenić)

Moje osobiste doświadczenia: biorąc pod uwagę napięty serwer z otwartym tylko jednym portem HTTPS (nie ma innego portu), wymagane certyfikaty klienckie i aktywne iptables, nadal był w stanie wymienić dostępne szyfry, podczas gdy top-głosowane rozwiązania nie były (próbowałem małego skryptu powłoki, SSL Labs, NMap, sslscan)

Szukając czegoś, co robi AUTH TLS na FTP, odkryłem to narzędzie: ssl-cipher-suite-enum

Jest to skrypt perlowy, który w zasadzie robi to, co robi skrypt powłoki hackajara, tylko bardziej zaawansowany.

Oferuje również podstawową ocenę oferowanych szyfrów i protokołów. Jest to trochę jak narzędzia SSL Labs, tylko do użytku domowego. :)

Domyślnie obsługuje tylko AUTH SSL na FTP, ale proste wyszukiwanie i wymiana może to naprawić. Jako bonus, twierdzi również, że wspiera SMTP z STARTTLS i RDP.