====== Openssl ======
Mit dem Programm ''openssl'' kann man Zertifikate erstellen und verwalten.
Zertifikate werden für verschiedene Zwecke benötigt. Z. B. werden sie für das Versenden von E-Mails, beim surfen im Internet oder für VPN-Verbindungen verwendet. Aber auch andere kommunikative Plattformen nutzen sie.
Sie beinhalten div. Informationen über den Aussteller, wie z.B. Land, Provinz, Stadt, Firmenname, Abteilungsname, ...
Wenn man z. B. auf Webseiten surft, welche mit TLS/SSL gesichert sind, also wenn man eine Seite mit "https" aufruft, dann ist der Aufruf meist ohne Schwierigkeiten oder Meldungen möglich.
Oft wird man aber vom Browser gefragt, ob man wirklich auf dieser Seite surfen möchte, da diese nicht Vertrauenswürdig ist. Warum ist das so?

Jeder kann sich Zertifikate ausstellen und jeder kann somit eine TLS/SSL -Gesicherte Webseite mit seinem Zertifikat versehen.
Das heißt aber noch lange nicht dass man der vermeintlichen Verschlüsselung trauen kann. Damit ein Zertifikat z.B. vom Browser als sicher bzw. vertrauenswürdig angenommen wird, muss das Zertifikat von einer vertrauenswürdigen Zertifikatsstelle ausgestellt worden sein.
Mit ''openssl'' erstellte Zertifikate sind also vielleicht, in ihrer Funktion, korrekt ausgestellte Zertifikate, die vielleicht alle Informationen über den Aussteller beinhalten. 
Da sie aber von der OpenSSL-CA (**C**ertificate **A**uthority -> Zertifizierungsstelle) ausgestellt wurden, sind sie nicht sicher bzw. vertrauenswürdig.
Selbsterstellte Zertifikate sind also mit vorsicht zu genießen.

===== Installation =====
''openssl'' ist in den Standardpaketquellen von Ubuntu vorhanden und kann somit einfach mit folgendem Befehl installiert werden.
<code bash>apt-get install openssl</code>

===== Vorbereitungen =====
Zunächst erstellt man die, evtl. nicht vorhandenen, Ordnerstruckturen.
<code bash>mkdir -p /etc/ssl/demoCA/certs /etc/ssl/demoCA/crl /etc/ssl/demoCA/newcerts /etc/ssl/demoCA/private</code>
Der Ornder "demoCA" wurde hier nur gewählt, weil es standardmäßig eingestellt ist. Diesen kann man aber in der Datei ''/etc/ssl/openssl.cnf'' ändern.
  
Nun muss man noch, falls nötig, folgenden Dateien erstellen.
<code bash>touch /etc/ssl/demoCA/index.txt
touch /etc/ssl/demoCA/serial
touch /etc/ssl/demoCA/crlnumber</code>

In der ''/etc/ssl/demoCA/serial'' gibt man eine Seriennummer ein z. B. "01".
In der ''/etc/ssl/demoCA/crlnumber'' gibt man eine Nummer ein z. B. "01".

^ Ordnername ^ Bezeichnung ^
| demoCA | openssl's Stammordner |
| demoCA/cacert.pem | CA Zertifikat |
| demoCA/serial | Ca Seriennummerndatei |
| demoCA/serial.old | Ca Seriennummerndatei Backup |
| demoCA/index.txt | CA Textdatenbankdatei |
| demoCA/index.txt.old | CA Textdatenbankdatei Backup |
| demoCA/.rand | CA random seed information |
| demoCA/certs | Hier werden alle ausgestellten Zertifikate abgelegt. |
| demoCA/crl | steht für **c**ertificate **r**evocation **l**ist, \\ Hier werden alle abgelaufenen oder gesperrten Zertifikate abgelegt. |
| demoCa/crlnumber | Eine Textdatei welche die als nächst zu verwendete Nummer für CRLs enthält. |
| demoCA/newcerts | Hier werden alle Zertifikatsanfragen abgelegt. |
| demoCA/private | Hier werden alle privaten Zertifikatsschlüssel abgelegt. |
| demoCA/private/cakey.pem | CA privater Schlüssel |

Wenn man viele Zertifikate erstellen möchte, dann bietet es sich an die Datei ''/etc/ssl/openssl.cnf'' anzupassen. Somit werden einige Fragen, welche beim Erstellen von Zertifikaten gestellt werden,
auf den jeweiligen Default-Wert gesetzt.

===== CA erstellen =====
Damit man Zertifikate selbst signieren kann, benötigt man eine CA.
Diese erstellt man sich, indem zunächst der private Schlüssel und danach das daraus resultierende Zertifikat für die CA erstellt wird.
<code bash>openssl req -new -x509 -days 3650 -extensions v3_ca -keyout /etc/ssl/demoCA/private/<CANAME>Key.pem -out /etc/ssl/demoCA/<CANAME>Cert.pem</code>

==== CA Vertrauensstellung ====
Damit unsere neue CA auch von Ubuntu vertraut wird, muss man noch das ''/etc/ssl/certs/ca-certificates.crt'' erneuern.
Dazu kopiert man das neu erstellte CA-Zertifikat nach ''/usr/share/ca-certificates/extra/''.
Wichtig ist dabei, dass es die Dateiendung **.crt** erhält.
<code bash>mkdir /usr/share/ca-certificates/extra
cp /etc/ssl/demoCA/<CANAME>Cert.pem /usr/share/ca-certificates/extra/<CANAME>Cert.crt
dpkg-reconfigure ca-certificates
update-ca-certificates</code>

===== Zertifikate erstellen =====
Das Erstellen von Zertifikaten erfolgt immer gleich. Man erstellt sich einen privaten Schlüssel und fragt mit diesem bei der CA ein Zertifikat an.
Die CA stellt dann das Zertifikat, welches von ihr selbst mit ihrem eigenen privaten Schlüssel signiert wird, aus.

==== Privaten Schlüssel erstellen ====
Man erstellt sich einen Privaten Schlüssel, welcher für das Signieren oder zum Verschlüsseln verwendet werden kann.
In diesem Beispiel ist der RSA Schlüssel 2048 Bit lang und wird mit AES256 verschlüsselt. Das Ausgabeformat ist ".pem"
<code bash>openssl genrsa -aes256 -out /etc/ssl/demoCA/private/<USER_ODER_HOST>Key.pem 2048</code>
Benötigt man einen DSA Schlüssel, welcher nur zum Signieren verwendet werden kann, dann müssen dafür zunächst Parameter dafür erstellt werden.
<code bash>openssl dsaparam -out /etc/ssl/demoCA/private/<USER_ODER_HOST>DsaParam.pem 2048</code>
Nun kann der Schlüssel generiert werden.
<code bash>openssl gendsa -aes256 -out /etc/ssl/demoCA/private/<USER_ODER_HOST>Key.pem /etc/ssl/demoCA/private/<USER_ODER_HOST>DsaParam.pem</code>
 
**WICHTIG:** Private Schlüssel sollten unbedingt gut behütet werden. Daher setzt man am Besten auch die Rechte folgendermaßen.
<code bash>chown root.root <PFAD_ZUM_PRIV_KEY>
chmod 400 <PFAD_ZUM_PRIV_KEY></code>

==== Zertifikatsanfrage erstellen ====
Mit dem neuen privaten Schlüssel stellt man bei der CA eine Anfrage für ein neues Zertifikat.
Hier wieder im ".pem" Ausgabeformat, da der private Schlüssel in diesem Format erstellt wurde.
<code bash>openssl req -new -key /etc/ssl/demoCA/private/<USER_ODER_HOST>Key.pem -out /etc/ssl/demoCA/newcerts/<USER_ODER_HOST>Req.csr</code>
Die Abfragen bei der Erstellung des Anfrage sollten hier je nach Zweck (für Host oder User) gewählt werden.

==== selbstsigniertes Zertifikat erstellen ====
Nun sendet man die ".csr" Datei an die CA die die Anfrage signieren soll. Wenn man eine eigene CA hat, dann kann diese die Anfrage signieren.
Hiermit signiert die CA ein neues, x.509 basiertes, Zertifikat im ".pem" Format, welches 1095 Tage (3 Jahre) gültig ist.
<code bash>openssl x509 -CA /etc/ssl/demoCA/<CANAME>Cert.pem -CAkey /etc/ssl/demoCA/private/<CANAME>Key.pem -CAserial /etc/ssl/demoCA/serial -in /etc/ssl/demoCA/newcerts/<USER_ODER_HOST>Req.csr -req -out /etc/ssl/demoCA/certs/<USER_ODER_HOST>Cert.pem -days 1095</code>

===== Mit Zertifikaten arbeiten =====
==== Zertifikate auf Konsole ausgeben ====
Mit folgendem Befehl kann man sich den Inhalt eines Requests ausgeben lassen.
<code bash>openssl req -text -noout -in <PFAD_ZU_REQUEST></code>
Hiermit kann man sich den Inhalt eines Zertifikats ausgeben lassen.
<code bash>openssl x509 -text -noout -in <PFAD_ZU_ZERTIFIKAT></code>
Bei ''pkcs12'' Zertifikaten verwendet man diesen Befehl zur ausgabe.
<code bash>openssl pkcs12 -info -in <PFAD_ZU_ZERTIFIKAT>.pfx | openssl x509 -noout -text</code>
==== Zertifikat verifizieren ====
Mit folgendem Befehl kann man Requests Verifizieren lassen.
<code bash>openssl req -verify -noout -in <PFAD_ZU_ZERTIFIKAT_ODER_REQUEST></code>
Hiermit kann man ein selbstsigniertes Zertifikat überprüfen.
<code bash>openssl verify -issuer_checks -CAfile <PFAD_ZU_CA-ZERTIFIKAT> <PFAD_ZU_ZERTIFIKAT></code>
oder
<code bash>openssl verify <PFAD_ZU_ZERTIFIKAT></code>
  
==== Übereinstimmung zum privaten Schlüssel ====
Möchte man feststellen ob die Zertifikatsanfrage bzw. das ausgestellte Zertifikat zum privaten Schlüssel passen, dann führt man folgendes aus.
<code bash>openssl rsa -noout -modulus -in <PFAD_ZUM_PRIV_KEY> > <KEY_AUSGABEDATEI>
openssl req -noout -modulus -in <PFAD_ZU_REQUEST> > <REQ_AUSGABEDATEI>
openssl x509 -noout -modulus -in <PFAD_ZU_ZERTIFIKAT> > <ZERT_AUSGABEDATEI></code>
Die Ausgabedateien müssen nun verglichen werden. Idealerweise weisen dann diese keinen Unterschied auf.

==== Fingerprint ausgeben ====
Mit folgendem Befehl kann man den Fingerabdruck eines Zertifikats ausgeben.
<code bash>openssl x509 -fingerprint -noout -md5 -in <PFAD_ZU_ZERTIFIKAT></code>
Man kann hier den Algorithmus (md5) durch einen anderen ersetzen (z.B: sha1).

==== Zertifikatformat ändern ====
Mit diesem Befehl kann man das Format eines Zertifikats ändern. Als Beispiel hier von "PEM" nach "DER".
<code bash>openssl crl -in <PFAD_ZU_QUELLZERTIFIKAT> -outform der -out <PFAD_ZU_ZIELZERTIFIKAT></code>

==== Private Key aus PKCS12 Zerifikat extrahieren ====
Wenn man nur ein PKCS12 Zertifikat mit dem integrieren priv. Schlüssel hat, und man diesen Key weiterverwenden möchte,
muss dieser extrahiert werden.
Mit diesen Befehlen trennt man das PKCS12 Zertifikat in ein x509 Zertifikat und den RSA priv. Schlüssel auf.
  * **Key extrahieren** \\ <code bash>openssl pkcs12 -in yourP12File.pfx -nocerts -out privateKey.pem</code>
  * **Zertifikat extrahieren** \\ <code bash>openssl pkcs12 -in yourP12File.pfx -clcerts -nokeys -out publicCert.pem</code>

==== Passphrase aus priv. Key extrahieren ====
Manchmal benötigt man einen privaten Schlüssel ohne Passphrase. Diese kann extrahiert werden.
<code bash>openssl rsa -in <KEYNAME_MIT_PASSPHRASE> -out <KEYNAME_OHNE_PASSPHRASE></code>
  
===== Zertifikate sperren =====
Um ein Zertifikat zu sperren, benötigt man sog. CRLs (**C**ertificate **R**evocation **L**ists).
Eine CRL erstellt man sich wie folgt.
<code bash>openssl ca -gencrl -cert /etc/ssl/demoCA/<CANAME>Cert.pem -keyfile /etc/ssl/demoCA/private/<CANAME>Key.pem -out demoCA/crl.pem</code>
==== Verfahren: Zertifikate sperren ====
Möchte man ein Zertifikat sperren, dann führt man u.g. Befehl aus. Dabei wird das Zertifikat in
der ''demoCA/index.txt'' als gesperrt aufgeführt.
<code bash>openssl ca -cert /etc/ssl/demoCA/<CANAME>Cert.pem -keyfile /etc/ssl/demoCA/private/<CANAME>Key.pem -revoke /etc/ssl/demoCA/certs/<USER_ODER_HOST>Cert.pem</code>
Die Einträge in der ''index.txt'' beginnen mit einem der folgenden Buchstaben **R**, **V** oder **E**.
^ Buchstabe ^ Bezeichnung ^
|  R  | Revoked |
|  V  | Valid |
|  E  | Expired |

Beim nächsten aktualisieren des CRL-Zertifikats wird diese dann übernommen und tatsächlich gesperrt.
Die Aktualisierung erfolgt standardmäßig nach 30 Tagen und kann in der ''openssl.cnf'' mit dem Parameter ''default_crl_days'' angepasst werden.
Wenn das Zertifikat sogar nach einigen Stunden gesperrt werden soll, dann fügt man dem o.g. Befehl den Parameter ''-crlhours <STUNDENZAHL>'' hinzu. Für Tage ''-crldays <TAGEZAHL>''
Wenn man die CRL **sofort aktualisieren** möchte, dann erstellt man sich die CRL (siehe oben) erneut mit dem selben Namen.

=== CRL ausgeben ===
Ist ein Zertifikat gesperrt, können mit folgendem Befehl die gesperrten Seriennummern ausgegeben werden.
<code bash>openssl crl -noout -text -CAfile self-signed-certificate.pem -in /etc/ssl/demoCA/crl.pem</code>

=== Zertifikate entsperren ===
Sollte aus Versehen ein Zertifikat gesperrt werden, löscht man den entsprechenden Eintrag aus der index.txt, wartet auf die nächste Aktualisierung oder erstellt die CRL neu.

===== Zertifikatsbeispiele =====
Mit ''openssl'' lassen sich verschiedenste Befehle für verschiedene Anwendungszwecke zusammenstellen.
Hier sind nur einige beschrieben. Weiter Infos findet man im Internet auf diversen Seiten.

==== TLS/SSL ====
Zertifikat für TLS/SSL Verschlüsselung.
<code bash>openssl genrsa 2048 -out /etc/ssl/demoCa/private/tlsKey.pem
chmod 400 /etc/ssl/demoCa/private/tlsKey.pem
openssl req -new -key /etc/ssl/demoCa/private/tlsKey.pem -out /etc/ssl/demoCA/newcerts/tlsKey.pem
openssl req -new -x509 -key /etc/ssl/demoCA/private/tlsKey.pem -out /etc/ssl/demoCA/certs/tlsCert.pem -days 1095</code>

==== PKCS#12 ====
PKCS#12 (**P**ublic **K**ey **C**ryptography **S**tandards) Zertifikate enthalten zu dem Zertifikat selbst noch den Privaten Schlüssel und sind daher Passwortgeschützt.
Infos findet man in der [[http://de.wikipedia.org/wiki/PKCS|Wikipedia]].
Wenn man ein PKCS#12 Zertifikat benötigt, dann kann man dies mit diesem Befehl machen.
<code bash>openssl pkcs12 -export -in /etc/ssl/demoCA/certs/<USER_ODER_HOST>Cert.pem -inkey /etc/ssl/demoCA/private/<USER_ODER_HOST>Key.pem -out /etc/ssl/demoCA/certs/<USER_ODER_HOST>Cert.p12</code>

=== PKCS12 Zertifikat Anzeigen ===
<code bash>openssl pkcs12 -in /etc/ssl/demoCA/certs/<USER_ODER_HOST>Cert.p12 | openssl x509 -noout -text</code>

=== PKCS12 nach x.509 pem konvertieren ===
privaten Schlüssel aus einer PFX-Datei in eine PEM-Datei extrahieren:
<code bash>openssl pkcs12 -in filename.pfx -nocerts -out key.pem</code>
Nur das Zertifikat exportieren:
<code bash>openssl pkcs12 -in filename.pfx -clcerts -nokeys -out cert.pem</code>
Entfernen des Kennworts aus dem extrahierten privaten Schlüssel:
<code bash>openssl rsa -in key.pem -out server.key</code>
==== HTTPS SSL testen ====
<code bash>openssl s_client -showcerts -connect <HOSTNAME>:443</code>
Danach mit <key>CRTL</key>+<key>D</key> rausgehen.
==== Mail TLS testen ====
<code bash>openssl s_client -starttls smtp -connect <DNS_ODER_IP_DES_MAILSERVERS>:25</code>
Danach mit "quit" rausgehen.

Quellen: 
[[http://www.openssl.org/docs/HOWTO|OpenSSL-Howto]]
[[http://www.dfn-cert.de/informationen/themen/verschluesselung_und_pki/openssl-kurzreferenz.html|www.dfn-cert.de-Informationenen]]