PKI Public Key Infrastructure: Zertifikate, CA & TLS/SSL

Dieser Beitrag ist eine umfassende Erläuterung der Public Key Infrastructure – inklusive Zertifikate, Certificate Authorities und TLS/SSL Implementierung.

In a Nutshell

PKI ist das organisatorische und technische Rahmenwerk zum Erstellen, Verteilen, Validieren und Widerrufen von öffentlichen Schlüsseln mittels Zertifikaten. Sie ermöglicht vertrauenswürdige Identitäten für Menschen, Maschinen und Dienste.

Kompakte Fachbeschreibung

Eine Public Key Infrastructure (PKI) besteht aus Root CA und nachgeordneten Intermediate CAs, die X.509 Zertifikate ausstellen, signieren und über CRL oder OCSP widerrufen.

Hauptkomponenten:

Certificate Authority (CA): Stellt Zertifikate aus
Registration Authority (RA): Prüft Identitäten
Certificate Repository: Speichert Zertifikate
Validation Authority: Validiert Zertifikate

Zertifikatsinhalte:

Public Key: Öffentlicher Schlüssel des Inhabers
Identity Information: CN, SAN, OU, O, C
Validity Period: Gültigkeitszeitraum
Key Usage: Zweckbindung des Schlüssels
Digital Signature: Signatur der ausstellenden CA

Vertrauensmodell:

Chain of Trust: Hierarchische CA-Struktur
Root Certificates: Vertrauensanker in Truststores
Certificate Validation: Prüfung der Zertifikatskette

PKI unterstützt Authentifizierung, Signatur, Verschlüsselung und Nichtabstreitbarkeit in TLS, S/MIME, Code Signing und mTLS.

Prüfungsrelevante Stichpunkte

Root CA und Intermediate CA Hierarchie
X.509 Zertifikatsformat und -inhalte
Chain of Trust und Truststore Management
CRL (Certificate Revocation List) und OCSP (Online Certificate Status Protocol)
TLS/SSL Handshake mit Zertifikatsvalidierung
CSR (Certificate Signing Request) Prozess
mTLS (Mutual TLS) für Client-Authentifizierung
IHK-relevant für IT-Sicherheit und Netzwerktechnik

Kernkomponenten

Root Certificate Authority: Oberste Vertrauensinstanz
Intermediate Certificate Authority: Zwischeninstanzen für Delegation
End Entity Certificate: Zertifikat für Server/Client/Dienste
Certificate Signing Request: Anfrage für Zertifikatsausstellung
Certificate Revocation List: Liste widerrufener Zertifikate
OCSP Responder: Online-Statusprüfung von Zertifikaten
Truststore: Speicher vertrauenswürdiger Root-Zertifikate
Keystore: Speicher eigener Zertifikate und privater Schlüssel

Praxisbeispiele

Zertifikat mit OpenSSL erstellen

# Private Key generieren
openssl genrsa -out server.key 2048

# Certificate Signing Request (CSR) erstellen
openssl req -new -key server.key -out server.csr \
  -subj "/C=DE/ST=Berlin/L=Berlin/O=IRC-Coding/OU=IT/CN=irc-coding.de"

# Self-signed Certificate (für Testing)
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

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

# Zertifikat validieren
openssl verify -CAfile ca.crt server.crt

Java Keystore Management

// Keystore mit KeyTool erstellen
// keytool -genkeypair -alias server -keyalg RSA -keysize 2048 \
//   -keystore keystore.jks -validity 365

// CSR exportieren
// keytool -certreq -alias server -keystore keystore.jks -file server.csr

// Zertifikat importieren
// keytool -importcert -alias server -file server.crt \
//   -keystore keystore.jks -trustcacerts

// Java Code für Zertifikatsvalidierung
import java.security.cert.*;
import java.io.FileInputStream;

public class CertificateValidator {
    
    public static boolean validateCertificate(String certPath, String caPath) {
        try {
            // Zertifikat laden
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            X509Certificate cert = (X509Certificate) 
                cf.generateCertificate(new FileInputStream(certPath));
            
            // CA-Zertifikat laden
            X509Certificate caCert = (X509Certificate) 
                cf.generateCertificate(new FileInputStream(caPath));
            
            // Zertifikatskette validieren
            cert.checkValidity(); // Gültigkeitszeitraum prüfen
            cert.verify(caCert.getPublicKey()); // Signatur prüfen
            
            // CRL/OCSP Prüfung (vereinfacht)
            if (isRevoked(cert)) {
                return false;
            }
            
            return true;
            
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    
    private static boolean isRevoked(X509Certificate cert) {
        // CRL oder OCSP Prüfung implementieren
        return false;
    }
}

TLS Server mit Node.js

const https = require('https');
const fs = require('fs');

// TLS Server Konfiguration
const tlsOptions = {
    key: fs.readFileSync('server.key'),
    cert: fs.readFileSync('server.crt'),
    ca: fs.readFileSync('ca.crt'), // Für Client-Authentifizierung
    requestCert: true,            // mTLS erfordern
    rejectUnauthorized: true       // Ungültige Zertifikate ablehnen
};

const server = https.createServer(tlsOptions, (req, res) => {
    // Client-Zertifikat-Informationen
    const clientCert = req.socket.getPeerCertificate();
    
    if (clientCert) {
        console.log('Client authenticated:', clientCert.subject.CN);
        res.writeHead(200);
        res.end('Hello authenticated client!');
    } else {
        res.writeHead(401);
        res.end('Client certificate required');
    }
});

server.listen(8443, () => {
    console.log('TLS Server listening on port 8443');
});

Python TLS Client mit Zertifikatsvalidierung

import ssl
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.ssl_ import create_urllib3_context

class TLSAdapter(HTTPAdapter):
    def init_poolmanager(self, *args, **kwargs):
        context = create_urllib3_context()
        context.check_hostname = True
        context.verify_mode = ssl.CERT_REQUIRED
        context.load_verify_locations('ca.crt')  # CA-Zertifikat laden
        
        # mTLS mit Client-Zertifikat
        context.load_cert_chain('client.crt', 'client.key')
        
        kwargs['ssl_context'] = context
        return super().init_poolmanager(*args, **kwargs)

# TLS-Client mit Zertifikatsvalidierung
session = requests.Session()
session.mount('https://', TLSAdapter())

try:
    response = session.get('https://secure-api.example.com/data')
    print("Response:", response.json())
except requests.exceptions.SSLError as e:
    print("TLS Error:", e)
except Exception as e:
    print("General Error:", e)

Certificate Revocation (CRL/OCSP)

// CRL-basierte Revocation Prüfung
import java.security.cert.*;
import java.net.URL;
import java.io.InputStream;

public class CRLValidator {
    
    public static boolean checkRevocation(X509Certificate cert) {
        try {
            // CRL Distribution Points aus Zertifikat extrahieren
            String crlUrl = getCRLDistributionPoint(cert);
            
            if (crlUrl != null) {
                // CRL herunterladen
                URL url = new URL(crlUrl);
                InputStream in = url.openStream();
                
                // CRL laden und validieren
                CertificateFactory cf = CertificateFactory.getInstance("X.509");
                X509CRL crl = (X509CRL) cf.generateCRL(in);
                
                // Prüfen ob Zertifikat widerrufen wurde
                return !crl.isRevoked(cert);
            }
            
            return true; // Keine CRL verfügbar
            
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    
    private static String getCRLDistributionPoint(X509Certificate cert) {
        // CRL Distribution Point aus Zertifikat-Extensions extrahieren
        // Implementierung würde ASN.1 Parsing erfordern
        return null;
    }
}

PKI-Hierarchie und Trust Chain

Typische PKI-Struktur

Root CA (selbstsigniert)
├── Intermediate CA 1 (für Web-Server)
│   ├── irc-coding.de
│   └── api.irc-coding.de
├── Intermediate CA 2 (für Code Signing)
│   ├── desktop-app.exe
│   └── mobile-app.apk
└── Intermediate CA 3 (für E-Mail)
    ├── user1@irc-coding.de
    └── user2@irc-coding.de

Zertifikatsvalidierungskette

public class ChainValidator {
    
    public static boolean validateChain(X509Certificate[] chain, 
                                       X509Certificate[] trustedCAs) {
        try {
            // Trust Anchors initialisieren
            Set<TrustAnchor> trustAnchors = new HashSet<>();
            for (X509Certificate ca : trustedCAs) {
                trustAnchors.add(new TrustAnchor(ca, null));
            }
            
            // PKIX-Parameter konfigurieren
            PKIXParameters params = new PKIXParameters(trustAnchors);
            params.setRevocationEnabled(true); // CRL/OCSP Prüfung aktivieren
            
            // Certificate Path Builder
            CertPathBuilder builder = CertPathBuilder.getInstance("PKIX");
            X509CertSelector selector = new X509CertSelector();
            selector.setCertificate(chain[0]);
            
            PKIXBuilderParameters builderParams = 
                new PKIXBuilderParameters(trustAnchors);
            builderParams.setRevocationEnabled(true);
            
            // Zertifikatskette validieren
            CertPathBuilderResult result = builder.build(builderParams);
            CertPathValidator validator = CertPathValidator.getInstance("PKIX");
            CertPathValidatorResult validatorResult = 
                validator.validate(result.getCertPath(), params);
            
            return true;
            
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

Vorteile und Nachteile

Vorteile von PKI

Sicherheit: Starke kryptographische Grundlage
Skalierbarkeit: Hierarchische Struktur für große Organisationen
Standardisierung: X.509 ist weit verbreitet
Flexibilität: Verschiedene Anwendungsfälle (TLS, Code Signing, etc.)
Nichtabstreitbarkeit: Digitale Signaturen beweisen Urheberschaft

Nachteile

Komplexität: Aufwendige Einrichtung und Wartung
Kosten: Commercial CAs verlangen Gebühren
Betriebsaufwand: Schlüsselrotation, Zertifikatsverwaltung
Single Point of Failure: Root CA Ausfall betrifft gesamte PKI

Häufige Prüfungsfragen

Was ist der Unterschied zwischen Root CA und Intermediate CA? Root CA ist selbstsigniert und Vertrauensanker, Intermediate CA ist von Root CA signiert und delegiert Ausstellung.
Erklären Sie den Chain of Trust! Hierarchische Validierung vom End-Zertifikat über Intermediate CAs bis zur Root CA.
Was ist der Zweck von CRL und OCSP? Überprüfung ob Zertifikate vor Ablauf widerrufen wurden (Compromise, Job-Change, etc.).
Wann verwendet man mTLS? Für gegenseitige Authentifizierung zwischen Server und Client (APIs, Microservices).