Passwörter: Wie sie geknackt werden

Wie werden Passwörter eigentlich gespeichert? In diesem Modul lernst du wie Hashing funktioniert, warum Salt wichtig ist und wie Angreifer Passwörter knacken. Du implementierst Hash-Funktionen in Python und lernst was ein sicheres Passwort ausmacht.

Wie werden Passwörter gespeichert?

Wenn du dich bei einer Website anmeldest, sendest du dein Passwort an den Server. Aber wie speichert die Website dein Passwort? Hoffentlich nicht im Klartext!

Die schlechteste Idee: Klartext

Wenn eine Datenbank Passwörter im Klartext speichert und gehackt wird, hat der Angreifer sofort alle Passwörter. Das ist so, als würdest du deinen PIN-Code auf die Bankkarte schreiben.

Die Lösung: Hashing

Statt das Passwort zu speichern, wird nur der Hash-Wert gespeichert. Beim Anmelden wird das eingegebene Passwort gehasht und mit dem gespeicherten Hash verglichen.

So kennt sogar die Website dein Passwort nicht!

Hashing mit Python

Mit dem Modul hashlib kannst du in Python einfach Hash-Werte berechnen:

import hashlib

def hash_password(password):
    return hashlib.sha256(password.encode()).hexdigest()

# Passwort speichern
pw_hash = hash_password("MeinGeheimesPasswort123")
print(f"Gespeicherter Hash: {pw_hash}")

# Beim Anmelden prüfen
eingabe = "MeinGeheimesPasswort123"
if hash_password(eingabe) == pw_hash:
    print("Login erfolgreich!")
else:
    print("Falsches Passwort!")

Beachte: Aus dem Hash kann man nicht auf das ursprüngliche Passwort zurückschliessen.

Salt: Hashing sicherer machen

Ein Problem von einfachem Hashing: Wenn zwei Benutzer dasselbe Passwort haben, entsteht derselbe Hash. Angreifer können Rainbow Tables verwenden – riesige Tabellen mit vorberechneten Hashes für häufige Passwörter.

Lösung: Salt – ein zufälliger Wert, der vor dem Hashing an das Passwort angehängt wird:

import hashlib
import os

def hash_with_salt(password):
    salt = os.urandom(32)
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # Iterationen = langsamer = sicherer
    )
    return salt + key

def verify_password(stored, password):
    salt = stored[:32]
    stored_key = stored[32:]
    new_key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000
    )
    return new_key == stored_key

hashed = hash_with_salt("Geheim123")
print(f"Richtiges PW: {verify_password(hashed, 'Geheim123')}")
print(f"Falsches PW: {verify_password(hashed, 'Falsch')}")

Passwort-Stärke und Brute-Force

Wie lange braucht ein Angreifer, um ein Passwort zu knacken?

Brute-Force-Angriff

Einfach alle möglichen Kombinationen ausprobieren. Die Zeit hängt von der Anzahl möglicher Zeichen und der Länge ab:

Regeln für starke Passwörter

• Länge: Mindestens 12 Zeichen
• Vielfalt: Gross-/Kleinbuchstaben, Zahlen, Sonderzeichen
• Keine Wörter: Keine Namen, Daten, bekannte Muster
• Einzigartig: Für jeden Account ein anderes Passwort