MBCDN

PEM erkennst man sofort am

-----BEGIN …-----

Binär/DER vs. P12/P7B erkennt man gut mit OpenSSL-Kommandos:

# Zertifikat (PEM oder DER)
openssl x509 -in file -text -noout
openssl x509 -in file -inform DER -text -noout

# Privater Schlüssel (viele Typen)
openssl pkey -in keyfile -text -noout

# PKCS#12
openssl pkcs12 -in file.p12 -info -noout

# PKCS#7 / CMS
openssl pkcs7 -in file.p7b -print_certs -noout
# oder
openssl cms -in file.p7b -print -noout

• als DER oder PEM
• Endungen: .crt, .cer, .pem, .der (alles möglich)

Die häufigsten Varianten (alle oft als DER oder PEM gespeichert):

• PKCS#1 (RSA-spezifisch): —–BEGIN RSA PRIVATE KEY—–
• SEC1 (EC-spezifisch, “traditional”): —–BEGIN EC PRIVATE KEY—–
• PKCS#8 (algorithmus-neutral, heute Standard):
• unverschlüsselt: —–BEGIN PRIVATE KEY—–
• verschlüsselt: —–BEGIN ENCRYPTED PRIVATE KEY—–

• PKCS#8/SubjectPublicKeyInfo: —–BEGIN PUBLIC KEY—–

• —–BEGIN CERTIFICATE REQUEST—– (oder NEW CERTIFICATE REQUEST)

• —–BEGIN X509 CRL—–

ASN.1 binär: BER / DER / CER

Fast alle klassischen X.509/TLS-Strukturen sind ASN.1-Objekte.

• BER (Basic Encoding Rules): flexibel, nicht eindeutig (mehrere Darstellungen möglich)
• DER (Distinguished…): eindeutig und daher sehr verbreitet (Zertifikate, Signaturen)
• CER (Canonical…): eher selten; v. a. wenn große Felder “chunked” codiert werden

DER = Distinguished Encoding Rules

• Binäres Format für ASN.1-Strukturen (z. B. X.509-Zertifikate, Schlüssel).
• Dateien heißen oft: .der, .cer, .crt (Endungen sind nicht eindeutig!)
• Vorteil: kompakt, eindeutig. Nachteil: nicht lesbar im Editor.

openssl x509 -in cert.der -inform DER -text -noout

PEM ist im Prinzip DER, aber Base64-kodiert und mit Text-Headern.

Erkennbar an Zeilen wie:

-----BEGIN CERTIFICATE-----
-----BEGIN PRIVATE KEY-----
-----BEGIN RSA PRIVATE KEY-----

• Dateien oft: .pem, .crt, .cer, .key (auch hier: Endungen sind nicht eindeutig!)
• Vorteil: leicht zu kopieren/verschicken, gut für Config-Files.

openssl x509 -in cert.pem -text -noout

Container die enthalten:

• Zertifikat,
• privKey,
• ggf Zertifikatskette

# Inhalt ansehen
openssl pkcs12 -in bundle.p12 -info -noout

# Zertifikat(e) extrahieren
openssl pkcs12 -in bundle.p12 -clcerts -nokeys -out cert.pem

# Privaten Schlüssel extrahieren
openssl pkcs12 -in bundle.p12 -nocerts -out key.pem

# Kette / CA Zertifikate anzeigen
openssl pkcs12 -in bundle.p12 -cacerts -nokeys -out chain.pem

JAVA Key Store

• Container für Zertifikate und/oder Signaturen
• normalerweise KEINE privaten Schlüssel
• häufig bei Windows-Zertifikatsketten, „Zertifikatbundle“

(OpenSSL nutzt dafür oft openssl pkcs7 oder moderner openssl cms.)

# Key-Typ bestimmen
openssl pkey -in key.pem -text -noout

# Private Key aus einem PEM (Key + Cert im selben File) extrahieren
openssl pkey -in fullchain_with_key.pem -out key.pem
# Key prüfen
openssl pkey -in privKey.pem -noout -text

# Private Key -> PKCS#8 (unencrypted)
openssl pkcs8 -topk8 -inform PEM -in key.pem -out key_pkcs8.pem -nocrypt
# Private Key -> PKCS#8 (encrypted)
openssl pkcs8 -topk8 -in key.pem -out key_pkcs8_enc.pem

# DER <-> PEM
openssl x509 -in cert.der -inform DER -out cert.pem -outform PEM

# PEM <-> DER
openssl x509 -in cert.pem -out cert.der -outform DER

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

openssl s_client -connect localhost:443 -debug

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

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

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.

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

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

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!

openssl aes-256-cbc -e -in file.zip -out file.zip.enc
openssl aes-256-cbc -d -in file.zip.enc -out file.zip

Das Passwort kann wieder mit RSA verschlüsselt werden.

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.

openssl dgst -sha256 -sign test.pri -out file.txt.sig.tmp file.txt
openssl base64 -in file.txt.sig.tmp -out file.txt.sig

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.

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

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

Konfiguration erstellen.

openssl.cnf

[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

Keys und Zertifikat erstellen

openssl req -x509 -nodes -newkey rsa:4096 -keyout server.key -out server.crt -days 365 -config openssl.cnf

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

Webserver-Zertifikat (TLS/SSL):

keyUsage = digitalSignature, keyEncipherment

CA-Zertifikat:

keyUsage = keyCertSign, cRLSign

Code Signing:

keyUsage = digitalSignature

Einen CSR (Certificate signing request) erstellen.

[ 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

[ 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

CSR generieren.

openssl req -new -key private.key -out signing.csr -config openssl-csr.cnf

Diesen CSR sendet man an die CA.

ROOT-CA Config

[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

INTERMEDIATE-CA Config

[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

CLIENT Config

[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

@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

• Docs