TLS-Zertifikate implementieren: Cs6262 Projekt 2 Netzwerksicherheit Leitfaden

Einleitung: Warum TLS-Zertifikate heute wichtiger sind denn je

Stell dir vor, du surfst durch das Internet und jeder Klick könnte deine Daten in falsche Hände geraten lassen. Genau hier kommen TLS-Zertifikate ins Spiel. Sie sind die digitalen Ausweise des Internets, die sicherstellen, dass du wirklich mit dem Server verbunden bist, den du erwartest – ähnlich wie ein KI-Chatbot, der deine Identität überprüft, bevor er sensible Informationen preisgibt. Im Cs6262 Projekt 2 – Network Security (Fall2025) implementierst du einen Teil dieser Funktionalität. Dieser Leitfaden hilft dir, die Grundlagen zu verstehen und deine eigene Lösung zu entwickeln.

Was sind TLS-Zertifikate und wie funktionieren sie?

Ein TLS-Zertifikat bindet einen Domainnamen (z.B. https://google.com) an eine Entität (Google, das Unternehmen). Eine Certificate Authority (CA) ist ein vertrauenswürdiger Dritter, der überprüft, ob eine Entität die Kontrolle über ihre Website hat. Wenn du eine Website in deinem Browser aufrufst, prüft dieser ein gültiges TLS-Zertifikat. Fehlt es oder ist es abgelaufen, warnt der Browser dich. In deinem Projekt implementierst du diese Prüfung mit Python und der Bibliothek pyOpenSSL.

Starter Code verstehen: Die Klasse TLSCertificateGrabber

Der vorgegebene Code definiert eine Klasse TLSCertificateGrabber, die einen TLS-Handshake durchführt und Zertifikatsdetails extrahiert. Hier ein Überblick über die Methoden:

connect_and_handshake(): Stellt eine SSL-Verbindung her.
get_certificate(): Holt das Zertifikat aus der Verbindung.
get_validity_start() und get_validity_end(): Geben die Gültigkeitsdauer im ASN.1-GeneralizedTime-Format zurück (z.B. 20250101000000Z).
get_certificate_authority(): Extrahiert den Common Name (CN) des Ausstellers.
get_public_key(): Gibt den öffentlichen Schlüssel als PEM-kodierten String zurück.

Implementierung Schritt für Schritt

1. Verbindung aufbauen und Handshake durchführen

In connect_and_handshake() erstellst du einen SSL-Kontext und verbindest dich mit dem Server. Hier ein Beispiel:

import ssl
import socket

class TLSCertificateGrabber:
    def __init__(self, hostname, port):
        self.hostname = hostname
        self.port = port

    def connect_and_handshake(self):
        context = ssl.create_default_context()
        sock = socket.create_connection((self.hostname, self.port))
        ssock = context.wrap_socket(sock, server_hostname=self.hostname)
        return ssock

2. Zertifikat extrahieren

Mit get_certificate() holst du das Zertifikat aus der SSL-Verbindung. pyOpenSSL bietet dafür die Methode getpeercert():

from OpenSSL import crypto

def get_certificate(self, ssl_sock):
    cert_der = ssl_sock.getpeercert(binary_form=True)
    cert = crypto.load_certificate(crypto.FILETYPE_ASN1, cert_der)
    return cert

3. Gültigkeitsdauer auslesen

Die Methoden get_validity_start und get_validity_end nutzen die Funktionen von pyOpenSSL, um die Zeiten im korrekten Format zurückzugeben:

def get_validity_start(self, cert):
    not_before = cert.get_notBefore().decode('utf-8')
    return not_before

def get_validity_end(self, cert):
    not_after = cert.get_notAfter().decode('utf-8')
    return not_after

4. Aussteller (Certificate Authority) ermitteln

Der Aussteller wird aus dem Zertifikat gelesen. Du suchst nach dem Common Name (CN):

def get_certificate_authority(self, cert):
    issuer = cert.get_issuer()
    components = issuer.get_components()
    for key, value in components:
        if key == b'CN':
            return value.decode('utf-8')
    return None

5. Öffentlichen Schlüssel abrufen

Der öffentliche Schlüssel wird als PEM-String zurückgegeben:

def get_public_key(self, cert):
    pub_key = cert.get_pubkey()
    return crypto.dump_publickey(crypto.FILETYPE_PEM, pub_key).decode('utf-8')

6. Alles zusammenführen: dump_certificate()

Diese Methode ruft alle vorherigen Methoden auf und gibt ein Tuple zurück:

def dump_certificate(self):
    ssl_sock = self.connect_and_handshake()
    cert = self.get_certificate(ssl_sock)
    not_before = self.get_validity_start(cert)
    not_after = self.get_validity_end(cert)
    issuer = self.get_certificate_authority(cert)
    public_key = self.get_public_key(cert)
    return cert, issuer, not_before, not_after, public_key

Teste deine Implementierung

Füge am Ende der Datei einen Testblock hinzu:

if __name__ == "__main__":
    service = TLSCertificateGrabber("cs6262.gtisc.gatech.edu", 443)
    response = service.dump_certificate()
    import pprint
    pprint.pprint(response)

Führe das Skript aus. Du solltest die Zertifikatsdetails sehen. Falls Fehler auftreten, überprüfe die Netzwerkverbindung und ob pyOpenSSL installiert ist.

Häufige Fehler und Lösungen

ImportError: Stelle sicher, dass pyOpenSSL installiert ist (pip install pyOpenSSL).
ConnectionError: Der Server könnte nicht erreichbar sein. Teste mit ping oder einem anderen Port.
Falsches Datumsformat: Die Ausgabe von get_notBefore() ist bereits im ASN.1-Format. Stelle sicher, dass du es nicht veränderst.

Trends und Praxisbezug: Warum dieses Wissen heute Gold wert ist

Mit dem Aufkommen von KI-gestützten Bedrohungen und dem Internet der Dinge (IoT) wird die Netzwerksicherheit immer wichtiger. Aktuelle Cybersecurity-Trends zeigen, dass SSL/TLS-Zertifikate eine zentrale Rolle in der sicheren Kommunikation spielen – sei es bei Online-Banking, Cloud-Diensten oder Smart-Home-Geräten. Dein Projekt bereitet dich auf reale Herausforderungen vor, wie sie auch in CTF-Wettbewerben oder bei Sicherheitsaudits vorkommen.

Weiterführende Ressourcen

pyOpenSSL Dokumentation: Offizielle Doku zu den verwendeten Funktionen.
RFC 5280: Standard für X.509-Zertifikate.
OWASP Transport Layer Protection: Best Practices für TLS.

Fazit

Mit diesem Leitfaden hast du die Grundlagen für die Implementierung des Cs6262 Projekts 2 – Network Security erlernt. Du kannst jetzt TLS-Zertifikate abrufen, ihre Gültigkeit prüfen und die Aussteller identifizieren. Dieses Wissen ist nicht nur für dein Studium relevant, sondern auch für deine zukünftige Karriere in der IT-Sicherheit. Viel Erfolg!