Siehe auch [[ssl|SSL]], [[OpenSSL]], [[x509]], [[CA]]

{{openssl.zip|OpenSSL}}

=====Windows PFX Zertifikat exportieren=====

<code powershell>
openssl pkcs12 -in certificate.pfx -nocerts -out privatekey.key -nodes
openssl pkcs12 -in certificate.pfx -clcerts -nokeys -out certificate.crt
openssl pkcs12 -in certificate.pfx -out certificate.pem -nodes
</code>

=====SSL Test=====

<code>
openssl s_client -connect localhost:443 -debug
</code>

=====Schlüsselpaar erzeugen=====

<code>
// generate private key
openssl genrsa 2048 > test.pri

// with password
// important to write bitsize (2048) as the last parameter
openssl genrsa -aes128 -passout pass:foobar 2048 > test.pri

// export public key
openssl rsa -in test.pri -pubout > test.pub

//verify
openssl rsa -pubin -in test.pub -text -noout
openssl rsa -in test.pri -check -text -noout
</code>

Der private Schlüssel ist streng geheim, der öffentliche kann wie eine Telefonnummer mit jedem geteilt werden.

=====Inhalte mit RSA ver/entschlüsseln=====

Möchte A an B eine verschlüsselte Nachricht senden, nimmt A den öffentlichen Schlüssel von B und verschlüsselt die Nachricht damit (**asymmetrisches Verfahren**). Entschlüsseln kann sie nur B mit seinem privaten Schlüssel.

<code>
openssl rsautl -in secret.txt -out secret.txt.enc -pubin -inkey test.pub -encrypt
openssl rsautl -in secret.txt.enc -out secret.txt -inkey test.pri -decrypt
</code>

ACHTUNG: Ist der zu verschlüsselnde Inhalt länger als der bei der Schlüsselerstellung verwendete Modulus funktioniert RSA nicht und man verwendet AES.

=====Dateien mit AES ver/entschlüsseln=====

Dabei wird der Inhalt nicht mit dem Public Key des Gegenüber sondern mit einem Passwort verschlüsselt (**symmetrisches Verfahren**) das man auch zum Entschlüsseln kennen muss!

<code>
openssl aes-256-cbc -e -in file.zip -out file.zip.enc
openssl aes-256-cbc -d -in file.zip.enc -out file.zip
</code>

Das Passwort kann wieder mit RSA verschlüsselt werden.

=====Datei signieren=====

Die Signierung (asymmetrisches Verfahren) dient als Beweis das eine Datei tatsächlich von besagtem Absender stammt. Möchte A die Datei, die er an B schickt signieren, nimmt A seinen privaten Schlüssel und erstellt in Verbindung mit dem Inhalt eine Signatur. Diese wird mit dem Inhalt mitgeschickt. 

<code>
openssl dgst -sha256 -sign test.pri -out file.txt.sig.tmp file.txt
openssl base64 -in file.txt.sig.tmp -out file.txt.sig
</code>

=====Signatur prüfen=====

B nimmt den öffentlichen Schlüssel von A und kann in Verbindung mit der Signatur feststellen, ob sie tatsächlich von A mit seinem privaten Schlüssel (den nur A hat) signiert wurde.

<code>
openssl base64 -d -in file.txt.sig -out file.txt.sig.tmp
openssl dgst -sha256 -verify test.pub -signature file.txt.sig.tmp file.txt
</code>

=====Base64=====

<code>
-A //output in 1 line
openssl enc -base64 -in sample.txt -out sample.b64
openssl enc -d -base64 -in sample.b64 -out sample.txt
</code>

=====Zertifikat=====

====Self Signed====

Konfiguration erstellen.

openssl.cnf
<code>
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn

[dn]
C = AT
ST = Vienna
L = Vienna
O = Brainworx 
OU = Cloud Services
CN = nextcloud.local
</code>

Keys und Zertifikat erstellen
<code>
openssl req -x509 -nodes -newkey rsa:4096 -keyout server.key -out server.crt -days 365 -config openssl.cnf
</code>

====Key Usage====

<box green>Beim Erstellen eines Certificate Signing Request (CSR) mit OpenSSL kann man im keyUsage Feld festlegen, wofür das Zertifikat verwendet werden darf.</box>

keyUsage ist eine X.509 v3 Extension, die festlegt, welche kryptografischen Operationen der Schlüssel ausführen darf.

===KeyUsage===

^Wert^Bedeutung^
| digitalSignature | Unterschreiben von Daten (z.B. TLS-Handshake, E-Mail) |
| nonRepudiation   | Beweis der Herkunft (nicht abstreitbar)               |
| keyEncipherment  | Verschlüsselung von Schlüsseln (RSA Key Transport)    |
| dataEncipherment | Direktes Verschlüsseln von Nutzdaten                  |
| keyAgreement     | Schlüsselvereinbarung (Diffie-Hellman, ECDH)          |
| keyCertSign      | Signieren von Zertifikaten (CA-Funktion)              |
| cRLSign          | Signieren von Certificate Revocation Lists            |
| encipherOnly     | Nur Verschlüsselung bei Schlüsselvereinbarung         |
| decipherOnly     | Nur Entschlüsselung bei Schlüsselvereinbarung         |

===ExtendedKeyUsage===

| Wert                    | Bedeutung                                                       |
| **serverAuth**          | Authentifizierung eines Servers (z. B. HTTPS-Serverzertifikat)  |
| **clientAuth**          | Authentifizierung eines Clients (z. B. VPN- oder E-Mail-Client) |
| **codeSigning**         | Signieren von Software oder Skripten                            |
| **emailProtection**     | S/MIME – Schutz und Signatur von E-Mails                        |
| **timeStamping**        | Signieren von Zeitstempeln (z. B. bei Signaturerstellung)       |
| **OCSPSigning**         | Signieren von OCSP-Responses                                    |
| **msSGC**               | Microsoft Server Gated Cryptography (veraltet)                  |
| **nsSGC**               | Netscape Server Gated Cryptography (veraltet)                   |
| **ipsecEndSystem**      | IPsec-Schlüssel für Endsystem (IKE)                             |
| **ipsecTunnel**         | IPsec-Schlüssel für Tunnelmodus                                 |
| **ipsecUser**           | IPsec-Schlüssel für Benutzer                                    |
| **anyExtendedKeyUsage** | Beliebiger Zweck erlaubt (kommt selten vor, unscharf)           |
| **smartcardLogon**      | Authentifizierung via Smartcard                                 |
| **documentSigning**     | Signieren von Dokumenten                                        |
| **secureEmail**         | Alternative Bezeichnung für emailProtection (RFC 5280)          |


===Beispiele===

Webserver-Zertifikat (TLS/SSL):

<code>
keyUsage = digitalSignature, keyEncipherment
</code>

CA-Zertifikat:

<code>
keyUsage = keyCertSign, cRLSign
</code>

Code Signing:

<code>
keyUsage = digitalSignature
</code>

====CSR====

Einen CSR (Certificate signing request) erstellen.
===OpenSSL Konfig===

==Webserver==
<code>
[ req ]
default_bits        = 4096
prompt              = no
default_md          = sha256
distinguished_name  = dn
req_extensions      = req_ext

[ dn ]
CN = www.zarat.at
O = Zarat
C = AT

[ req_ext ]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[ alt_names ]
DNS.1 = www.zarat.at
DNS.2 = zarat.at
</code>

==DocumentSigning==

<code>
[ req ]
default_bits        = 4096
prompt              = no
default_md          = sha256
distinguished_name  = dn
req_extensions      = req_ext

[ dn ]
CN = Zarat Signatur
O = Zarat
C = AT

[ req_ext ]
keyUsage = critical, digitalSignature
extendedKeyUsage = codeSigning
subjectAltName = @alt_names

[ alt_names ]
DNS.1 = zarat.at
</code>

CSR generieren.
<code bash>
openssl req -new -key private.key -out signing.csr -config openssl-csr.cnf
</code>

Diesen CSR sendet man an die CA.
=====CA erstellen=====

ROOT-CA Config
<code>
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn

[dn]
C = AT
ST = Vienna
L = Vienna
O = Root Authority
OU = Root CA
CN = root-ca.local
</code>

INTERMEDIATE-CA Config

<code>
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn

[dn]
C = AT
ST = Vienna
L = Vienna
O = Brainworx
OU = Intermediate CA
CN = intermediate-ca.local
</code>

CLIENT Config

<code>
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn

[dn]
C = AT
ST = Vienna
L = Vienna
O = Brainworx
OU = Cloud Services
CN = nextcloud.local
</code>

<code>
@echo off

@rem Root CA Key und selbst-signiertes Zertifikat erstellen
openssl req -newkey rsa:2048 -nodes -keyout apitest01-ca.key -x509 -days 3650 -out apitest01-ca.crt -config root-openssl.cnf
pause

@rem Intermediate CA Key erzeugen
openssl genrsa -out apitest01-intermediate.key 2048
pause

@rem Intermediate CA CSR erzeugen
openssl req -new -key apitest01-intermediate.key -out apitest01-intermediate.csr -config intermediate-openssl.cnf
pause

@rem Intermediate CA mit Root CA signieren
openssl x509 -req -in apitest01-intermediate.csr -CA apitest01-ca.crt -CAkey apitest01-ca.key -set_serial 100 -days 3650 -out apitest01-intermediate.crt
pause

@rem Client Key erzeugen
openssl genrsa -out apitest01-client.key 2048
pause

@rem Client CSR erzeugen
openssl req -new -key apitest01-client.key -out apitest01-client.csr -config client-openssl.cnf
pause

@rem Client Zertifikat mit Intermediate CA signieren
openssl x509 -req -in apitest01-client.csr -CA apitest01-intermediate.crt -CAkey apitest01-intermediate.key -set_serial 101 -days 365 -out apitest01-client.crt
pause

@rem --- Client Zertifikat und Schlüssel in .p12 Datei exportieren ---
@rem Bündle Client Zertifikat und Schlüssel in eine PKCS#12 Datei
openssl pkcs12 -export -inkey apitest01-client.key -in apitest01-client.crt -out apitest01-client.p12
pause
</code>

=====Links=====

  * [[https://docs.openssl.org/3.4/man1/openssl/#standard-commands|Docs]]