Hoe kan ik de SSL/TLS codeer suites die een bepaalde website aanbiedt opnoemen?

Ik heb een bash script geschreven om codeer suites te testen. Het krijgt een lijst met ondersteunde codeer suites van OpenSSL en probeert met elke suite verbinding te maken. Als de handdruk succesvol is, drukt het YES af. Als de handdruk niet succesvol is, drukt het NO af, gevolgd door de OpenSSL fouttekst.

#!/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 is een voorbeelduitvoer die 3 niet-ondersteunde cijfers toont, en 1 ondersteund cijfer:

[@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: Voeg flexibiliteit toe als host en poort worden als parameter aan het script geleverd.

Nmap met ssl-enum-ciphers

Er is geen betere of snellere manier om een lijst met beschikbare cijfers van een netwerkdienst te krijgen. Bovendien geeft nmap voor elk beschikbaar cijfer een sterktebeoordeling van sterk, zwak of onbekend.

Download eerst het ssl-enum-ciphers.nse nmap-script uitleg hier ). Voer vervolgens vanuit dezelfde directory als het script de volgende nmap uit:

Lijstcijfers ondersteund door een HTTP-server

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

Lijstcijfers ondersteund door een IMAP-server

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

Hier is een fragment van de uitvoer van een IMAP-server van 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
``` &001

Is er een tool die kan testen welke SSL/TLS-coderingssuites een bepaalde website biedt?

Ja, u kunt de online tool op SSL Labs ’ website gebruiken om de openbare SSL-serverdatabase te bevragen.

Hier is een stukje informatie dat het biedt:

(screenshot van de resultaten van google.com)

Het test de verbinding met TLS en SSL (en het build script kan linken met zijn eigen kopie van OpenSSL zodat ook verouderde SSL-versies worden gecontroleerd) en rapporteert over de cijferreeksen en het certificaat van de server.

Voorbeeld uitvoer voor google.com (bijgesneden voor leesbaarheid):

$ 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

Aangezien dit zo'n geweldige referentiedraad is voor SSL-scanprogramma’s, zal ik CipherScan, dat een jaar geleden is gemaakt, op een rijtje zetten en kan ik ook problemen identificeren met sleuteluitwisselingscodes https://github.com/jvehent/cipherscan

Als u mijn vork wilt die SNI en FreeBSD ondersteunt, dan is de URL i https://github. com/oparoz/cipherscan

Het is een script dat openssl s_client aanroept en ondersteunt met behulp van uw eigen OpenSSL binair, zodat u aankomende functies of nieuwe cijfers kunt testen (chacha20+poly1305 per voorbeeld).

Het laat je ook toe om verbinding te maken met elke poort die je wilt en om starters te gebruiken.

Hier is een typische uitvoer

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

En hier zijn een lijst van opties

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

De json uitvoer is nuttig als je dit aanroept vanuit andere scripts.

https://github.com/iSECPartners/sslyze ](https://github.com/iSECPartners/sslyze)

Deze is gebaseerd op Python, werkt in Linux/Mac/Windows vanaf de opdrachtregel.

Na een beetje googelen vond ik deze Testing for SSL-TLS (OWASP-CM-001) :

De nmap -scanner, via de “-sV”-scanoptie, is in staat om SSL-services te identificeren. Kwetsbaarheidsscanners kunnen, naast het uitvoeren van service discovery, ook controles bevatten tegen zwakke cijfers (de Nessus-scanner heeft bijvoorbeeld de mogelijkheid om SSL-services op willekeurige poorten te controleren en zal zwakke cijfers rapporteren).

en ook: Foundstone SSL Digger is een hulpmiddel om de sterkte van SSL-servers te beoordelen door de ondersteunde cijfers te testen. Van sommige van deze cijfers is bekend dat ze onveilig zijn.

Ik gebruik voor de meeste SSL-testen testssl.sh (zie https://testssl.sh / ontwikkelversie @ https://github.com/drwetter/testssl.sh . Er wordt getest op kwetsbaarheden, cijfers, protocollen, enz.

Als je een mooie grepable output wilt (en ondersteuning voor het controleren van alle SSL/TLS versies)

Gebruik: ./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 is geweldig; een nieuwe tool SSLDiagnos werkt voor Windows, of je kunt gewoon een script schrijven met behulp van de openssl s_client.

Op basis van @indiv’s antwoord en de suggestie om het als eigen antwoord te posten, geef ik mijn aangepaste versie van @indiv’s script. U kunt een host aanleveren als eerste argument, en deze zal dezelfde resultaten opleveren als het oorspronkelijke script, maar dan iets meer geformatteerd:

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

Er is een leuk klein scriptje op pentesterscripting.com om zowel SSLScan als OpenSSL te gebruiken om te controleren op:

• SSL v2;
• Week ciphers suits;
• MD5; en
• TLS Renegotiation vulnerability http://www. pentesterscripting.com/discovery/ssl_tests (via het Internet Archief Wayback Machine )

Hier gedupliceerd voor futureproofing aangezien de hoofdsite nu dood is:

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

Gebruik: ./ssltest.sh HOST PORT

Het script van Nmap ssl-enum-ciphers kan een overzicht geven van de ondersteunde cijfers en SSL/TLS-versies, evenals de ondersteunde compressoren.

De (gratis) OpenSSL Cookbook van Ivan Ristić, die de SSL Labs online tool heeft ontwikkeld die in Kez’s antwoord staat:

Als u alle suites wilt bepalen die door een bepaalde server worden ondersteund, begin dan met het aanroepen van openssl ciphers ALL om een lijst te krijgen van alle suites die door uw versie van OpenSSL worden ondersteund. Dien ze vervolgens één voor één in bij de server om ze individueel te testen. Ik suggereer niet dat u dit handmatig doet; dit is een situatie waarin een beetje automatisering een lange weg is. In feite is dit een situatie waarin ** het zoeken naar een goede tool misschien wel gepast is**.

Er is echter een nadeel aan het testen op deze manier. U kunt alleen de suites testen die OpenSSL ondersteunt. …

Geen enkele SSL/TLS-bibliotheek ondersteunt alle cijferreeksen , en dat maakt uitgebreid testen moeilijk. Voor SSL Labs heb ik voor dit doel gebruik gemaakt van gedeeltelijke handshakes, met een aangepaste client die doet alsof hij willekeurige suites ondersteunt. Het kan zelfs niet onderhandelen over een enkele suite, maar alleen maar voorstellen om te onderhandelen is genoeg voor servers om u te vertellen of ze een suite ondersteunen of niet. Je kunt niet alleen alle suites op deze manier testen, maar je kunt het ook heel efficiënt doen.

(Mijn nadruk.)

Een tool die ik niet heb gezien in andere antwoorden is Stephen Bradshaw’s SSLTest , die onder andere bedoeld is om “de gedetecteerde cijfers en protocollen te vergelijken met compliance standaarden zoals DSD ISM en PCI-DSS. ”

Dus, probeer dit of een van de hulpmiddelen die in de andere antwoorden worden genoemd, of bouw je eigen hulpmiddel en overweeg het gebruik van Ristić’s benadering van gedeeltelijke handdrukken.

Dit antwoord vat het best gegeven antwoord samen en beargumenteert waarom we een alternatief moeten kiezen (of niet!).

• *

Om de beste oplossing te vinden, moeten we eerst antwoorden “waarom willen we alle ondersteunde cijfers opnoemen?”. Hier ligt de focus op het beveiligingsaspect, d.w.z. om te weten te komen of een server kwetsbaar is of niet. De volgende vraag om te beantwoorden is of de uitvoer machinaal leesbaar moet zijn, bijvoorbeeld om verder te worden gebruikt in een script, of niet.

1. testssl.sh

• CLI (Bash)
• TLSv1. 3
• Controles op bekende kwetsbaarheden
• Zelfstandig (geen installatie nodig)
• Ondersteunt 370 cijfers (vanaf versie 3.1) inclusief afgeschreven cijfers (niet opgenomen in nieuwere openSSL-versies)
• Produceert machinaal leesbare resultaten (CSV en JSON)
• (geparalleliseerde) batchverwerking
• Slow

Misschien wel het belangrijkste voordeel van testssl.sh ten opzichte van de volgende alternatieven is het gebruik van een set binaries die op maat zijn gemaakt voor het testen van de kwetsbaarheid (lees de uitleg van de ontwikkelaar hier ).

2. cipherscan

• CLI (python)
• Geen TLSv1.3
• Zelfstandige
• Beperkte cijferreeksen (hard-coded)
• Produceert machineleesbare resultaten (JSON)
• Snelle

3. nmap ssl-enum-ciphers

• CLI (nmap script)
• Geen TLSv1.3
• Zelfstandige
• Beperkte cijferreeksen (hard-coded)
• Controles op bekende kwetsbaarheden
• Geen machineleesbare resultaten

Voor een uitputtend overzicht van de beschikbare hulpmiddelen, zie sslLabs Beoordelingshulpmiddelen .

SSLyze, oorspronkelijk op https://github.com/iSECPartners/sslyze , is nu op https://github.com/nabla-c0d3/sslyze . Het werd vermeld in een ander antwoord , maar zonder veel details.

SSLyze is gebaseerd op Python en werkt op Linux/Mac/Windows vanaf de opdrachtregel. Het gebruikt OpenSSL, en op Windows wordt het geleverd met een gebundelde kopie van OpenSSL.

Lijsten met protocollen, cijferreeksen en belangrijke details, plus tests voor enkele veelvoorkomende kwetsbaarheden. Het is mogelijk om bepaalde controles in of uit te schakelen, om meer gegevens te krijgen of de scan te versnellen.

Ik heb een instrument geschreven dat precies dit doet. Het heet tlsenum en het is beschikbaar op 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 is een voorbeeld uitvoer van de tool tegen twitter.com.

Het is vergelijkbaar met wat SSL Lab’s doet, maar ik vind het veel nuttiger om een command line tool te hebben die je kunt automatiseren en ontleden.

Al die antwoorden zijn prima. Een deel van het antwoord zou kunnen verklaren waarom we een tool nodig hebben om de lijst van de server te ontdekken en niet direct in TLS te vragen of die server al zijn ondersteunde cijferreeksen geeft, zoals TLS-client doet wanneer hij verbinding maakt met een server.

Antwoord is dat server nooit een lijst stuurt, het selecteert gewoon in de clientversleutelingslijst het cijfer dat het wil gebruiken, dit is de manier waarop het SSL/TLS-protocol wordt geschreven : http://wiki. opensslfoundation.com/index.php/SSLenTLSProtocols#CipherSuites

Daarom moet de client de codes opnoemen om deze te kunnen vinden die door de server worden ondersteund en daarvoor minstens één nieuwe start handshake (ClientHello) te doen voor elke cipher suite.

Het enige wat je kunt doen is ze allemaal een voor een uitproberen en kijken welke worden geaccepteerd. Ik ben niet op de hoogte van een tool om dit te doen, hoewel het niet moeilijk zou moeten zijn om er een in elkaar te flansen van scripting tools en openssl s_client.

Terwijl de client adverteert welke ciphersuites hij accepteert, kiest de server er gewoon een en gebruikt deze of faalt de verbinding als hij niets vindt wat hij leuk vindt.

TestSSLServer ](http://www.bolet.org/TestSSLServer/) is een puur op Java gebaseerde oplossing. Voordelen:

• het werkt op zeer laag niveau, alleen op gewone Sockets, dus het is onafhankelijk van mogelijke niet-beschikbare cijfers van JDK of OpenSSL.

• het vereist geen extra poorten (zoals ICMP voor ping) om te openen

• het werkt met aanwezige klantencertificaten

Nadelen:

• vanaf 2016 kan de lijst met cijfers verouderd zijn (hoewel ik hier geen expert ben om dit te beoordelen)

Mijn persoonlijke ervaring: gezien een tight-laced server met slechts een enkele HTTPS-poort open (geen andere poort), clientcertificaten vereist en iptables actief zijn, was het nog steeds in staat om de beschikbare cijfers op te sommen, terwijl top-gevraagde oplossingen dat niet waren (ik probeerde kleinschalige shell script, SSL Labs, NMap, sslscan)

Terwijl ik op zoek was naar iets dat AUTH TLS op FTP doet, ontdekte ik deze tool: Het is een perl script dat in principe doet wat hackajar’s shell script doet, alleen meer verfijnd.

Het biedt ook een basisevaluatie van aangeboden cijfers en protocollen. Het lijkt een beetje op SSL Labs tools, alleen voor thuisgebruik. :)

Standaard ondersteunt het alleen AUTH SSL op FTP, maar een simpele zoek en vervanger kan dat verhelpen. Als bonus beweert het ook SMTP te ondersteunen met STARTTLS en RDP.