# TLS / SSL

# OpenSSL - TLS-/SSL-Zertifikate

#### OpenSSL - Zertifikate anzeigen/prüfen/testen

<div id="bkmrk-zertifikat-komplett-"><div>- <div>Zertifikat komplett anzeigen</div>

</div></div>```
openssl x509 -noout -text -in <zertifikatsname.crt>
```

<div id="bkmrk-den-herausgeber-des-"><div>- <div>den Herausgeber des Zertifikats anzeigen</div>

</div></div>```
openssl x509 -noout -issuer -in <zertifikatsname.crt>
```

<div id="bkmrk-f%C3%BCr-wen-wurde-das-ze"><div>- <div>Für wen wurde das Zertifikat ausgestellt?</div>

</div></div>```
openssl x509 -noout -subject -in <zertifikatsname.crt>
```

<div id="bkmrk-f%C3%BCr-welchen-zeitraum"><div>- <div>Für welchen Zeitraum ist das Zertifikat gültig?</div>

</div></div>```
openssl x509 -noout -dates -in <zertifikatsname.crt>
```

<div id="bkmrk-das-obige-kombiniert"><div>- <div>das obige kombiniert anzeigen</div>

</div></div>```
openssl x509 -noout -issuer -subject -dates -in <zertifikatsname.crt>
```

<div id="bkmrk-den-hash-anzeigen"><div>- <div>den hash anzeigen</div>

</div></div>```
openssl x509 -noout -hash -in <zertifikatsname.crt>
```

<div id="bkmrk-den-md5-fingerprint-"><div>- <div>den MD5-Fingerprint anzeigen</div>

</div></div>```
openssl x509 -noout -fingerprint -in <zertifikatsname.crt>
```

<div id="bkmrk-ein-ssl-zertifikat-p"><div>- <div>ein SSL-Zertifikat prüfen</div>

</div></div>```
openssl verify -verbose <zertifikatsname.crt>
```

<div id="bkmrk-einen-ssl-port-auf-z"><div>- <div>einen SSL-Port auf Zertifikate abfragen (Beispiel LDAP)</div>

</div></div>```
echo QUIT | openssl s_client -connect localhost:636 -showcerts
```

<div id="bkmrk-ein-https-serverzert"><div>- <div>ein HTTPS-Serverzertifikat runterladen</div>

</div></div>```
echo QUIT | openssl s_client -connect www.magenbrot.net:443 | sed -ne '/BEGIN CERT/,/END CERT/p' > zertifikat.crt
```

<div id="bkmrk-ein-https-serverzert-1"><div>- <div>ein HTTPS-Serverzertifikat runterladen und in lesbar ausgeben</div>

</div></div>```
echo QUIT | openssl s_client -connect www.magenbrot.net:443 | openssl x509 -noout -text
```

<div id="bkmrk-g%C3%BCltigkeit-eines-htt"><div>- <div>Gültigkeit eines HTTPS-Serverzertifikats anzeigen</div>

</div></div>```
echo QUIT | openssl s_client -connect www.magenbrot.net:443 2>/dev/null | openssl x509 -noout -dates
```

<div id="bkmrk-bei-webservern-mit-s"><div>- <div>bei Webservern mit SNI muss der gewünschte Host im Header mitgeschickt werden, da sonst das SSL-Zertifikat des Default-Vhosts ausgeliefert wird</div>

</div></div>```
echo QUIT | openssl s_client -tls1_2 -servername ovtec.it -connect ovtec.it:443 | openssl x509 -noout -text
```

<div id="bkmrk-das-gleiche-f%C3%BCr-mail"><div>- <div>das Gleiche für Mailservices mit STARTTLS (SMTP, IMAP, POP3)</div>

</div></div>```
# herunterladen und in Datei speichern:
echo QUIT | openssl s_client -starttls smtp -crlf -connect mailgw.ovtec.it:25 | sed -ne '/BEGIN CERT/,/END CERT/p' > zertifikat.crt
echo QUIT | openssl s_client -starttls pop3 -crlf -connect mail.ovtec.de:110 | sed -ne '/BEGIN CERT/,/END CERT/p' > zertifikat.crt
echo QUIT | openssl s_client -starttls imap -crlf -connect mail.ovtec.de:143 | sed -ne '/BEGIN CERT/,/END CERT/p' > zertifikat.crt

# in lesbar ausgeben:
echo QUIT | openssl s_client -starttls smtp -crlf -connect mailgw.ovtec.it:25 | openssl x509 -noout -text
echo QUIT | openssl s_client -starttls pop3 -crlf -connect mail.ovtec.de:110 | openssl x509 -noout -text
echo QUIT | openssl s_client -starttls imap -crlf -connect mail.ovtec.de:143 | openssl x509 -noout -text
```

#### CSR erzeugen/anzeigen (Certificate Signing Request)

Wenn Ihr ein offizielles Zertifikat bestellen wollt, müsst ihr für die Certificate Authority (CA) einen Zertifikatsantrag erstellen. Dieser wird auf der Webseite Eurer CA (z.B. Thawte, Geotrust, Startssl) hochgeladen und die CA erzeugt daraus dann das endgültige Zertifikat, das ihr dann zusammen mit den Zwischenzertifikaten (intermediate-certificate) herunterladen könnt.

Die aktuellen Browser verlangen die Angabe der DNS-Namen, die im Zertifikat enthalten sein sollen, in einer X509v3 Erweiterung zu OpenSSL als sogenannte „Subject Alternative Names“ (SAN). Der CommonName alleine reicht nicht mehr aus.

Umlaute im Städte- oder Firmennamen sind mit utf8 auch kein Problem mehr.

Ich habe eine [Konfigurationsdatei](https://wiki.magenbrot.net/_media/linux/kryptographie/ssl/request.cnf "linux:kryptographie:ssl:request.cnf (500 B)") erstellt, die ihr herunterladen und für eure Zwecke anpassen könnt. Das erstellen eines 4096-Bit Keys und passender CSR ist dann kein Problem mehr und mit einem Kommando erledigt:

```
# Konfigurationsdatei herunterladen und anpassen
wget -O request.cnf https://wiki.magenbrot.net/_media/linux/kryptographie/ssl/request.cnf
vi request.cnf # SAN anpassen!

# 4096-bit Key erstellen und das CSR mit den Angaben aus der Konfigurationsdatei generieren
openssl req -nodes -newkey rsa:4096 -keyout ovtec.it.key -new -out ovtec.it.csr -config request.cnf

# CSR anzeigen lassen (mit UTF8)
openssl req -noout -text -nameopt utf8 -in ovtec.it.csr
```

<div id="bkmrk-alte-anleitung%3A-mit-"><div>- <div>ALTE Anleitung: mit diesen Kommandos könnt ihr einen Key und das dazu gehörende CSR erstellen</div>

</div></div>```
# 4096 Bit RSA-Key erzeugen
openssl genrsa -out <zertifikatsname.key> 4096

# den CSR dazu erzeugen
openssl req -new -sha256 -key <zertifikatsname.key> -out <zertifikatsname.csr>

#jetzt sind ein paar Fragen zu beantworten (gibt man nur einen . ein so bleibt das Feld leer):
Country Name (2 letter code) [AU]:DE
State or Province Name (full name) [Some-State]:Bayern
Locality Name (eg, city) []:Fuerth
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Deine Firma
Organizational Unit Name (eg, section) []:.

Common Name (eg, YOUR name) []:www.meinedomain.de
Email Address []:webmaster@meinedomain.de

Please enter the following 'extra' attributes to be sent with your certificate request
A challenge password []:
An optional company name []:
```

\# (optional) den Key mit einer Passphrase versehen. Diese Passphrase wird dann z.B. beim Starten von Apache abgefragt. Also Achtung: Ein automatischer Start des Apachen ist dann nur noch mit weiteren Tricks möglich.

```
openssl rsa -des3 -in <zertifikatsname.key> -out <zertifikatsname.key.sec>
```

<div id="bkmrk-einen-csr-%28zertifika">- <div>einen CSR (Zertifikatsrequest) anzeigen</div>

</div>```
openssl req -noout -text -in <request.csr>
```

<div id="bkmrk-"></div>#### Passphrase entfernen/ändern

<div id="bkmrk-passphrase-f%C3%BCr-ein-k">- <div>Passphrase für ein Keyfile entfernen/ändern (RSA Keys)</div>

</div>```
# Passphrase entfernen
openssl rsa -in <zertifikatsname.key> -out <neueskeyfile.key>

# Passphrase ändern
openssl rsa -des3 -in <zertifikatsname.key> -out <neueskeyfile.key>
```

<div id="bkmrk-passphrase-f%C3%BCr-ein-k-1">- Passphrase für ein Keyfile entfernen/ändern (ECC Keys)

</div>```
# Passphrase entfernen
openssl pkey -in <zertifikatsname.key> -out <neueskeyfile.key>

# Passphrase ändern
openssl pkey -des3 -in <zertifikatsname.key> -out <neueskeyfile.key>
```

<div id="bkmrk--1"></div>#### Selbstsignierte (selfsigned) Zertifikate erstellen

Diese Zertifikate können für interne Zwecke eingesetzt werden oder für den Zeitraum bis man von der Trusted CA sein richtiges Zertifikat bekommt. Mit wenigen Schritten ist ein solches Zertifikat erstellt, diese Beispiel erzeugt ein für 60 Tage gültiges Zertifikat:

```
openssl genrsa -out <zertifikatsname.key> 4096
[...]
openssl req -new -sha256 -key <zertifikatsname.key> -out <zertifikatsname.csr> #(siehe oben)
[...]
openssl x509 -req -sha256 -days 60 -in <zertifikatsname.csr> -signkey <zertifikatsname.key> -out <zertifikatsname.crt>
[...]
```

oder als komfortabler Einzeiler:

```
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -sha256 -nodes -subj "/C=DE/ST=Bayern/L=Nuernberg/O=Firma/CN=app.mytest.de"
```

#### Zertifikate konvertieren

<div id="bkmrk-pem-nach-der"><div>- <div>PEM nach DER</div>

</div></div>```
openssl x509 -outform der -in certificate.pem -out certificate.der
```

<div id="bkmrk-pem-nach-p7b"><div>- <div>PEM nach P7B</div>

</div></div>```
openssl crl2pkcs7 -nocrl -certfile certificate.cer -out certificate.p7b -certfile CACert.cer
```

<div id="bkmrk-pem-nach-pkcs12-%28p12"><div>- <div>PEM nach PKCS12 (P12)</div>

</div></div>```
openssl pkcs12 -export -out certificate.p12 -inkey userkey.pem -in usercert.pem 
```

<div id="bkmrk-pem-nach-pfx"><div>- <div>PEM nach PFX</div>

</div></div>```
openssl pkcs12 -export -out certificate.pfx -inkey privateKey.key -in certificate.crt -certfile CACert.crt
```

<div id="bkmrk-der-nach-pem"><div>- <div>DER nach PEM</div>

</div></div>```
openssl x509 -inform der -in certificate.cer -out certificate.pem
```

<div id="bkmrk-p7b-%2F-pkcs7-nach-pem"><div>- <div>P7B / PKCS7 nach PEM</div>

</div></div>```
openssl pkcs7 -print_certs -in certificate.p7b -out certificate.cer
```

<div id="bkmrk-p7b-%2F-pkcs7-nach-pfx"><div>- <div>P7B / PKCS7 nach PFX</div>

</div></div>```
openssl pkcs7 -print_certs -in certificate.p7b -out certificate.cer
openssl pkcs12 -export -in certificate.cer -inkey privateKey.key -out certificate.pfx -certfile CACert.cer
```

<div id="bkmrk-pfx-%2F-pkcs12-nach-pe"><div>- <div>PFX / PKCS12 nach PEM</div>

</div></div>```
# es wird nach dem Import-Passwort gefragt, wenn eines gesetzt wurde:
openssl pkcs12 -in certificate.pfx -out certificate.pem -nodes

# beim Fehler "Mac verify error: invalid password?" bitte mit der nächsten Methode probieren
```

<div id="bkmrk-pfx-%2F-pkcs12-nach-pe-1"><div>- <div>PFX / PKCS12 nach PEM (wenn er das Passwort nicht frisst):</div>

</div></div>```
openssl pkcs12 -in certificate.pfx -out certificate.pem  -nodes -password pass:<PASSWORT>
```

#### PEM-Datei richtig erstellen

Seit Apache 2.4.8 ist SSLCertificateChainFile als deprecated markiert. Das heißt, dass nun Zertifikat und Zwischenzertifikat in einer gemeinsamen Datei gespeichert werden müssen und über die Direktive SSLCertificateFile geladen werden.

Dabei ist die Reihenfolge wichtig. Eine solche Datei wird folgendermaßen erstellt:

<div id="bkmrk-cat-meine-domain.de."><div><dl><dd>```
cat meine-domain.de.crt ssl-ca-intermediate.crt > meine-domain.de-bundle.crt
```

</dd></dl></div></div>Ganz selten wird auch das Root der SSL-CA benötigt, das hängt dann einfach ganz am Ende dran:

<div id="bkmrk-cat-meine-domain.de.-0"><div><dl><dd>```
cat meine-domain.de.crt ssl-ca-intermediate.crt ssl-ca-root.crt > meine-domain.de-bundle.crt
```

</dd></dl></div></div>Um solche Dateien einfach zu erkennen, füge ich ein -bundle in den Dateinamen ein.

##### PEM inklusive private Key

Es kann auch noch der SSL-Key eingefügt werden. Dieser kommt dann an erster oder letzter Stelle. Die Zertifikate übrigen in der üblichen Reihenfolge (Zertifikat, Intermediate und gegebenenfalls noch das Root-Zertifikat). Apache unterstützt das zwar, es wird allerdings aktuell [nicht empfohlen](https://httpd.apache.org/docs/2.4/mod/mod_ssl.html#sslcertificatefile "https://httpd.apache.org/docs/2.4/mod/mod_ssl.html#sslcertificatefile").

<div id="bkmrk-cat-meine-domain.de.-1"><div><dl><dd>```
cat meine-domain.de.key meine-domain.de.crt ssl-ca-intermediate.crt (ssl-ca-root.crt) > meine-domain.de-bundle.crt
```

</dd></dl></div></div>Folgender Einzeiler baut das entsprechende PEM-File zusammen, falls Key und Zertifikat in zwei Dateien mit den Endungen .key und .crt vorliegen:

```
for i in `ls *.key`; do NAME=$(echo $i | sed 's/.key//'); echo $NAME; cat $NAME.crt $NAME.key >> $NAME.pem; rm $NAME.crt $NAME.key; done
```

#### Prüfen ob ein Zertifikat zu einem Key passt

Der private Teil eines Schlüssels enthält verschiedene Zahlen. Zwei dieser Zahlen bilden den „Publiy Key“ (diese Zahlen sind dann auch im Zertifikat erhalten), der Rest gehört zum „Private Key“. Um zu prüfen, ob der public key zum private key passt, können diese beiden Zahlen ausgelesen und verglichen werden.

```
# Zertifikate
$ openssl x509 -noout -modulus -in server.crt | openssl md5
# Private Schlüssel
$ openssl rsa -noout -modulus -in server.key | openssl md5
# Zertifikatsanforderung
$ openssl req -noout -modulus -in server.csr | openssl md5
```

oder als einfach zu verwendendes Script:

```
#!/bin/bash
#
# check if certificate, signing request and key match
#
# $Id: check-certificate.sh 524 2016-01-15 11:30:11Z magenbrot $
# zlFamous added intermediate and key size check
#
 
if [ "x$1" = "x" ]; then
  echo "Usage: $0 <filename without .key, .crt, .csr or .intermediates>"
  exit 1
fi
 
if [ -e $1.key ]; then
  output="$1.key: `openssl rsa -noout -modulus -in $1.key | openssl md5 | cut -d" " -f2`"
  key_size=`openssl rsa -noout -text -in $1.key | grep "Private-Key" | cut -d" " -f2 | cut -d"(" -f2`
  if [ $key_size -lt 4096 ]; then
    output="$output \e[39m(key size: \e[33m$key_size\e[39m bit)"
  else
    output="$output \e[39m(key size: \e[32m$key_size\e[39m bit)"
  fi
  echo -e $output
else
  echo "$1.key: file not found"
fi
 
if [ -e $1.csr ]; then
  echo -n "$1.csr: "
  openssl req -noout -modulus -in $1.csr | openssl md5 | cut -d" " -f2
else
  echo "$1.csr: file not found"
fi
 
if [ -e $1.crt ]; then
  echo -n "$1.crt: "
  openssl x509 -noout -modulus -in $1.crt | openssl md5 | cut -d" " -f2
else
  echo "$1.crt: file not found"
fi
 
if [ -e $1.intermediates ]; then
  echo -n "$1.intermediates: "
  subject=`openssl x509 -noout -subject_hash -in $1.intermediates`
  issuer=`openssl x509 -noout -issuer_hash -in $1.crt`
  if [ "$subject" != "" -o "$issuer" != "" ]; then
    if [ "$subject" == "$issuer" ]; then
      signature=`openssl x509 -noout -text -in $1.intermediates | grep "Signature Algorithm:" | cut -d" " -f7 | head -n1`
      echo -e "\e[32missuer matches subject \e[39m- signature hash: \e[32m$signature\e[39m"
    else
      echo -e "\e[31missuer doesn't match subject"
    fi
  fi
else
  echo "$1.intermediates: file not found"
fi
```

<div id="bkmrk--2"></div>

# Diffie-Hellman Parameterdatei Bitgröße ermitteln

Auf Diffie-Hellman aufsetzende Cipher benötigen eine entsprechende Parameterdatei. Die Standardgröße beträgt 1024 bit. Die Empfehlung nach der Logjam-Attacke sind mind. 2048 bit, besser 4096 bit.

Die Parameterdatei wird folgendermaßen erstellt:

<div id="bkmrk-openssl-dhparam--out"><div>```
openssl dhparam -out dhparams.pem 4096
```

</div></div>Aus der Datei läßt sich die Bitgröße nicht auf Anhieb herauslesen. Mit diesem Befehl lässt sich die Info darstellen:

<div id="bkmrk-openssl-dhparam--inf">```
openssl dhparam -inform PEM -in dhparams.pem -check -text
```

</div>

# (Zwischen-)Zertifikat Key und Zertifikatsrequest per Script auf Plausibilität prüfen

Dieses Script prüft folgende Punkte:

<div id="bkmrk-mind.-4096-bit-key-p"><div>- <div>mind. 4096 Bit Key</div>
- <div>Passen CSR, CRT, KEY zusammen (openssl modulus / md5)?</div>
- <div>Signatur-Hash prüfen</div>
- <div>Passt das Intermediate-CRT zum CRT</div>

</div></div>Namenskonvention der Dateien:

<div id="bkmrk-meine-domain.de.key-">- <div>meine-domain.de.key</div>
- <div>meine-domain.de.crt</div>
- <div>meine-domain.de.csr</div>
- <div>meine-domain.de.intermediates</div>

```shell
#!/bin/bash<br></br>#<br></br># check if certificate, signing request and key match<br></br>#<br></br><br></br>if [ "x$1" = "x" ]; then<br></br>  echo "Usage: $0 <filename without .key, .crt, .csr or .intermediates>"<br></br>  exit 1<br></br>fi<br></br><br></br>if [ -e $1.key ]; then<br></br>  output="$1.key: `openssl rsa -noout -modulus -in $1.key | openssl md5 | cut -d" " -f2`"<br></br>  key_size=`openssl rsa -noout -text -in $1.key | grep "Private-Key" | cut -d" " -f2 | cut -d"(" -f2`<br></br>  if [ $key_size -lt 4096 ]; then<br></br>    output="$output \e[39m(key size: \e[33m$key_size\e[39m bit)"<br></br>  else<br></br>    output="$output \e[39m(key size: \e[32m$key_size\e[39m bit)"<br></br>  fi<br></br>  echo -e $output<br></br>else<br></br>  echo "$1.key: file not found"<br></br>fi<br></br><br></br>if [ -e $1.csr ]; then<br></br>  echo -n "$1.csr: "<br></br>  openssl req -noout -modulus -in $1.csr | openssl md5 | cut -d" " -f2<br></br>else<br></br>  echo "$1.csr: file not found"<br></br>fi<br></br><br></br>if [ -e $1.crt ]; then<br></br>  echo -n "$1.crt: "<br></br>  openssl x509 -noout -modulus -in $1.crt | openssl md5 | cut -d" " -f2<br></br>else<br></br>  echo "$1.crt: file not found"<br></br>fi<br></br><br></br>if [ -e $1.intermediates ]; then<br></br>  echo -n "$1.intermediates: "<br></br>  subject=`openssl x509 -noout -subject_hash -in $1.intermediates`<br></br>  issuer=`openssl x509 -noout -issuer_hash -in $1.crt`<br></br>  if [ "$subject" != "" -o "$issuer" != "" ]; then<br></br>    if [ "$subject" == "$issuer" ]; then<br></br>      signature=`openssl x509 -noout -text -in $1.intermediates | grep "Signature Algorithm:" | cut -d" " -f7 | head -n1`<br></br>      echo -e "\e[32missuer matches subject \e[39m- signature hash: \e[32m$signature\e[39m"<br></br>    else<br></br>      echo -e "\e[31missuer doesn't match subject"<br></br>    fi<br></br>  fi<br></br>  chown root:root $1.intermediates<br></br>  chmod 0600 $1.key $1.csr $1.crt $1.intermediates<br></br>else<br></br>  echo "$1.intermediates: file not found"<br></br>fi
```

</div>

# CAcert Root Zertifikat unter Debian/Ubuntu einbinden

Da das CAcert Root Zertifikat leider nicht mehr mit Debian und damit auch nicht mit Ubuntu ausgeliefert wird folgt hier eine Anleitung, wie man es im System einbindet. Das betrifft nur das Betriebssystem, ggf. muss das Zertifikat auch in euren Browser importiert werden.

Dazu müssen die CAcert Root Zertifikate (root.crt und class3.crt) in einem Verzeichnis unterhalb von /usr/local/share/ca-certificates abgelegt werden und das Zertifikatsbundle neu erzeugt werden.

<div id="bkmrk-mkdir-%2Fusr%2Flocal%2Fsha">```
mkdir /usr/local/share/ca-certificates/cacert.org
wget -P /usr/local/share/ca-certificates/cacert.org http://www.cacert.org/certs/root.crt http://www.cacert.org/certs/class3.crt
update-ca-certificates
```

</div>

# Signatur-Algorithmen einer Zertifikatskette anzeigen

Da mit SHA1 signierte Zertifikate inzwischen als unsicher eingestuft werden, habe ich nach einer einfachen Möglichkeit gesucht, wie ich herausfinden kann, welche meiner Zertifikate davon betroffen sind.

Es reicht allerdings nicht, nur das Serverzertifikat auszutauschen. Es sollte auch die Zertifikatskette (Certificate chain) untersucht werden, da ggf. auch das Zwischen- und CA-Zertfikat ausgetauscht werden muss. Wobei das CA-Zertifikat natürlich nur von der CA, bzw. dem Herausgeber selbst (Geotrust, Thawte, etc) ausgetauscht werden kann.

Aufgerufen wird das Script so (kann dann z.B. in einer Schleife mit euren verschiedenen Servern/Ports gefüttert werden):

<div id="bkmrk-%23-.%2Fcheck-ssl-chain."><div>```
# ./check-ssl-chain.sh www.heise.de:443
    Signature Algorithm: sha256WithRSAEncryption
        Subject: C=DE, ST=Niedersachsen, L=Hannover, O=Heise Zeitschriften Verlag GmbH und Co KG, OU=Netzwerkadministration, CN=www.heise.de
    Signature Algorithm: sha256WithRSAEncryption

    Signature Algorithm: sha256WithRSAEncryption
        Subject: C=US, O=thawte, Inc., CN=thawte SHA256 SSL CA
    Signature Algorithm: sha256WithRSAEncryption
```

</div></div>oder:

<div id="bkmrk-%23-.%2Fcheck-ssl-chain.-0"><div>```
# ./check-ssl-chain.sh google.com:443
    Signature Algorithm: sha1WithRSAEncryption
        Subject: C=US, ST=California, L=Mountain View, O=Google Inc, CN=google.com
    Signature Algorithm: sha1WithRSAEncryption

    Signature Algorithm: sha1WithRSAEncryption
        Subject: C=US, O=Google Inc, CN=Google Internet Authority G2
    Signature Algorithm: sha1WithRSAEncryption

    Signature Algorithm: sha1WithRSAEncryption
        Subject: C=US, O=GeoTrust Inc., CN=GeoTrust Global CA
    Signature Algorithm: sha1WithRSAEncryption
```

</div></div>Das Beispiel 1 (Heise) zeigt, dass der Admin fleissig war und die Zertifikate schon gegen SHA256-signierte ausgetauscht hat. Google hingegen setzt noch mit SHA1 signierte Zertifikate ein.

Hier noch das Script:

<div id="bkmrk-%23%21%2Fbin%2Fsh-%C2%A0-host%3D%241-">```
<span class="co0">#!/bin/sh</span>
 
<span class="re2">HOST</span>=<span class="re4">$1</span>
<span class="re2">TMP</span>=<span class="sy0">`</span><span class="kw2">mktemp</span> -d<span class="sy0">`</span>
 
<span class="kw3">echo</span> QUIT <span class="sy0">|</span> openssl s_client <span class="re5">-showcerts</span> <span class="re5">-connect</span> <span class="re1">$HOST</span> <span class="nu0">2</span><span class="sy0">>/</span>dev<span class="sy0">/</span>null <span class="sy0">|</span> <span class="kw2">sed</span> <span class="re5">-ne</span> <span class="st_h">'/BEGIN CERT/,/END CERT/p'</span> <span class="sy0">|</span> <span class="kw2">awk</span> <span class="re5">-v</span> <span class="re2">TMP</span>=<span class="st0">"<span class="es2">$TMP</span>"</span> <span class="st_h">'/BEGIN/{n++}{print >TMP"/out" n ".crt" }'</span>
 
<span class="kw1">for</span> i <span class="kw1">in</span> <span class="sy0">`</span><span class="kw2">ls</span> <span class="re1">$TMP</span><span class="sy0">/</span>out<span class="sy0">*`</span>; <span class="kw1">do</span>
  openssl x509 <span class="re5">-in</span> <span class="re1">$i</span> <span class="re5">-noout</span> <span class="re5">-text</span> <span class="sy0">|</span> <span class="kw2">egrep</span> <span class="st0">"Signature Algorithm|Subject:"</span>
  <span class="kw3">echo</span>
<span class="kw1">done</span>
 
<span class="kw2">rm</span> <span class="re5">-rf</span> <span class="re1">$TMP</span>
```

</div>