OpenSSL ist das Standard-Tool für SSL/TLS-Zertifikate unter Linux. Es ermöglicht das Erstellen von CSRs, selbstsignierten Zertifikaten und internen Certificate Authorities.

Private Keys

RSA-Key erstellen

# 2048 Bit (Minimum)
openssl genrsa -out private.key 2048

# 4096 Bit (empfohlen)
openssl genrsa -out private.key 4096

# Mit Passwort
openssl genrsa -aes256 -out private.key 4096

EC-Key erstellen

# Elliptic Curve (moderner, schneller)
openssl ecparam -genkey -name prime256v1 -out private.key

# Ohne Passwort-Prompt
openssl ecparam -genkey -name secp384r1 -noout -out private.key

Key prüfen

# RSA
openssl rsa -in private.key -check

# EC
openssl ec -in private.key -text

# Passwort entfernen
openssl rsa -in encrypted.key -out decrypted.key

Certificate Signing Request (CSR)

CSR erstellen

# Interaktiv
openssl req -new -key private.key -out request.csr

# Mit Parametern
openssl req -new -key private.key -out request.csr \
    -subj "/C=DE/ST=Berlin/L=Berlin/O=Firma/OU=IT/CN=example.de"

Key und CSR in einem Schritt

openssl req -new -newkey rsa:4096 -nodes \
    -keyout private.key -out request.csr \
    -subj "/C=DE/ST=Berlin/L=Berlin/O=Firma/CN=example.de"

CSR prüfen

openssl req -in request.csr -text -noout
openssl req -in request.csr -verify

CSR mit SAN (Subject Alternative Names)

# Config-Datei erstellen
cat > san.cnf << EOF
[req]
default_bits = 4096
distinguished_name = req_distinguished_name
req_extensions = req_ext

[req_distinguished_name]
C = DE
ST = Berlin
L = Berlin
O = Firma
CN = example.de

[req_ext]
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.de
DNS.2 = www.example.de
DNS.3 = api.example.de
IP.1 = 192.168.1.10
EOF

# CSR mit SAN
openssl req -new -key private.key -out request.csr -config san.cnf

Selbstsignierte Zertifikate

Einfaches Zertifikat

# Key und Zertifikat (1 Jahr)
openssl req -x509 -newkey rsa:4096 -nodes \
    -keyout private.key -out certificate.crt \
    -days 365 \
    -subj "/C=DE/ST=Berlin/L=Berlin/O=Firma/CN=example.de"

Mit SAN

openssl req -x509 -newkey rsa:4096 -nodes \
    -keyout private.key -out certificate.crt \
    -days 365 -config san.cnf \
    -extensions req_ext

Aus bestehendem Key

openssl req -x509 -key private.key -out certificate.crt \
    -days 365 \
    -subj "/C=DE/ST=Berlin/L=Berlin/O=Firma/CN=example.de"

Eigene Certificate Authority

Root-CA erstellen

# Root-Key (mit Passwort!)
openssl genrsa -aes256 -out ca.key 4096

# Root-Zertifikat (10 Jahre)
openssl req -x509 -new -key ca.key -out ca.crt \
    -days 3650 \
    -subj "/C=DE/ST=Berlin/L=Berlin/O=Firma/CN=Firma Root CA"

Server-Zertifikat signieren

# Config für Server-Zertifikat
cat > server.cnf << EOF
[req]
default_bits = 4096
distinguished_name = req_distinguished_name
req_extensions = req_ext

[req_distinguished_name]
CN = server.example.de

[req_ext]
subjectAltName = @alt_names
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth

[alt_names]
DNS.1 = server.example.de
DNS.2 = www.server.example.de
EOF

# Server-Key und CSR
openssl req -new -newkey rsa:4096 -nodes \
    -keyout server.key -out server.csr \
    -subj "/C=DE/O=Firma/CN=server.example.de"

# Mit CA signieren
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
    -CAcreateserial -out server.crt \
    -days 365 -extfile server.cnf -extensions req_ext

Client-Zertifikat

# Client-Key und CSR
openssl req -new -newkey rsa:4096 -nodes \
    -keyout client.key -out client.csr \
    -subj "/C=DE/O=Firma/CN=Client Name"

# Signieren
openssl x509 -req -in client.csr -CA ca.crt -CAkey ca.key \
    -CAcreateserial -out client.crt -days 365 \
    -extfile <(echo "extendedKeyUsage = clientAuth")

# Als PKCS12 (für Browser)
openssl pkcs12 -export -out client.p12 \
    -inkey client.key -in client.crt -certfile ca.crt

Zertifikate prüfen

Lokales Zertifikat

# Zertifikat anzeigen
openssl x509 -in certificate.crt -text -noout

# Ablaufdatum
openssl x509 -in certificate.crt -enddate -noout

# Fingerprint
openssl x509 -in certificate.crt -fingerprint -sha256 -noout

# Subject und Issuer
openssl x509 -in certificate.crt -subject -issuer -noout

Remote-Zertifikat

# Server-Zertifikat prüfen
openssl s_client -connect example.de:443 </dev/null 2>/dev/null | \
    openssl x509 -text -noout

# Nur Ablaufdatum
echo | openssl s_client -connect example.de:443 2>/dev/null | \
    openssl x509 -noout -enddate

# Kette anzeigen
openssl s_client -connect example.de:443 -showcerts </dev/null

# Mit SNI
openssl s_client -connect example.de:443 -servername example.de

Zertifikat-Kette prüfen

# Kette verifizieren
openssl verify -CAfile ca.crt server.crt

# Vollständige Kette
openssl verify -CAfile ca.crt -untrusted intermediate.crt server.crt

Formate konvertieren

PEM zu DER

openssl x509 -in cert.pem -outform DER -out cert.der
openssl rsa -in key.pem -outform DER -out key.der

DER zu PEM

openssl x509 -in cert.der -inform DER -out cert.pem
openssl rsa -in key.der -inform DER -out key.pem

PEM zu PKCS12

openssl pkcs12 -export -out cert.p12 \
    -inkey private.key -in certificate.crt \
    -certfile ca.crt

PKCS12 zu PEM

# Zertifikat
openssl pkcs12 -in cert.p12 -clcerts -nokeys -out cert.pem

# Key
openssl pkcs12 -in cert.p12 -nocerts -nodes -out key.pem

Zertifikate zusammenfügen

# Chain-Datei erstellen
cat certificate.crt intermediate.crt root.crt > chain.pem

# Für Nginx
cat certificate.crt intermediate.crt > fullchain.pem

Praktische Scripts

Zertifikat-Check

#!/bin/bash
# check-cert.sh

DOMAIN=$1
DAYS_WARN=30

EXPIRY=$(echo | openssl s_client -connect ${DOMAIN}:443 2>/dev/null | \
    openssl x509 -noout -enddate | cut -d= -f2)

EXPIRY_EPOCH=$(date -d "$EXPIRY" +%s)
NOW_EPOCH=$(date +%s)
DAYS_LEFT=$(( (EXPIRY_EPOCH - NOW_EPOCH) / 86400 ))

if [ $DAYS_LEFT -lt $DAYS_WARN ]; then
    echo "WARNING: $DOMAIN expires in $DAYS_LEFT days"
    exit 1
else
    echo "OK: $DOMAIN valid for $DAYS_LEFT days"
    exit 0
fi

CSR-Info extrahieren

#!/bin/bash
# csr-info.sh

echo "Subject:"
openssl req -in $1 -subject -noout

echo ""
echo "Public Key:"
openssl req -in $1 -pubkey -noout

echo ""
echo "Signature Algorithm:"
openssl req -in $1 -text -noout | grep "Signature Algorithm"

Zusammenfassung

| Befehl | Funktion | |--------|----------| | genrsa | RSA-Key erstellen | | req -new | CSR erstellen | | req -x509 | Selbstsigniert | | x509 -req | CSR signieren | | x509 -text | Zertifikat anzeigen | | s_client | Remote prüfen |

| Datei | Inhalt | |-------|--------| | .key | Private Key | | .csr | Certificate Request | | .crt/.pem | Zertifikat | | .p12/.pfx | PKCS12 Bundle |

| Format | Beschreibung | |--------|--------------| | PEM | Base64 (-----BEGIN) | | DER | Binär | | PKCS12 | Bundle mit Key |

Fazit

OpenSSL ist das zentrale Tool für Zertifikatsverwaltung. Selbstsignierte Zertifikate eignen sich für interne Dienste. Für öffentliche Websites ist Let's Encrypt einfacher. Eine eigene CA macht Sinn für viele interne Server. Regelmäßige Prüfung der Ablaufdaten verhindert Ausfälle.