Passwortsicherheit 2025: Welche Hash-Algorithmen sind wirklich sicher?

Sie entwickeln eine neue App und müssen Benutzerpasswörter speichern. Einfach, oder? Einfach hashen und fertig.

Falsch.

Ich habe zu viele Entwickler die gleichen Fehler machen sehen: SHA-256 für Passwörter verwenden (es ist schnell, aber das ist das Problem), Salts vergessen oder veraltete Algorithmen nutzen. Im Jahr 2025 geht es bei der Passwortsicherheit nicht nur um Hashing—es geht darum, den richtigen Algorithmus zu wählen und ihn korrekt zu implementieren.

Dieser Leitfaden schafft Klarheit. Wir vergleichen die wichtigsten Algorithmen, zeigen Ihnen, was tatsächlich funktioniert, und geben Ihnen echte Code-Beispiele, die Sie heute verwenden können.

Testen Sie die Algorithmen selbst: Sie können direkt testen, wie schnell verschiedene Hashes sind, mit unseren Tools Bcrypt Generator und Hash Generator.

Warum Passwort-Hashing wichtig ist (Die wahre Geschichte)

Lassen Sie mich Ihnen ein Bild malen. Ihre Datenbank wird kompromittiert (es passiert öfter, als Sie denken). Wenn Sie Passwörter im Klartext gespeichert haben, haben Angreifer jetzt jedes Benutzerpasswort. Game over.

Hashing konvertiert Passwörter in unverständliche Zeichenketten, die nicht umkehrbar sind. Selbst wenn Angreifer Ihre Datenbank stehlen, können sie die Passwörter nicht direkt lesen. Aber hier ist der Haken: Nicht jedes Hashing ist gleich.

Das Problem mit schnellen Hashes: Algorithmen wie SHA-256 oder MD5 wurden für Datenintegrität entwickelt, nicht für Sicherheit. Sie sind schnell—zu schnell. Angreifer können Milliarden von Hashes pro Sekunde auf einer einzelnen GPU berechnen. Ihr "sicheres" Passwort? In Minuten geknackt.

Die Lösung: Verwenden Sie langsame, speziell entwickelte Passwort-Hashing-Algorithmen. Wir sprechen von Bcrypt, Argon2 oder PBKDF2. Diese Algorithmen sind absichtlich langsam, was Brute-Force-Angriffe unpraktisch macht.

Die drei Säulen: Salting, Peppering und Key Stretching

Bevor wir uns mit spezifischen Algorithmen befassen, schauen wir uns die Grundlagen an, die Passwort-Hashing sicher machen.

Salting: Ihre erste Verteidigungslinie

Ein Salt sind zufällige Daten, die jedem Passwort vor dem Hashing hinzugefügt werden. Warum? Weil identische Passwörter unterschiedliche Hashes produzieren sollten. Ohne Salts können Angreifer Rainbow Tables—vorkalkulierte Hash-Datenbanken—verwenden, um Passwörter sofort zu knacken.

So funktioniert es in der Praxis:

// Node.js: Bcrypt verwaltet Salts automatisch
const bcrypt = require('bcrypt');

async function hashPassword(password) {
  // Bcrypt generiert ein eindeutiges Salt für jedes Passwort
  // Cost Factor 12 = gute Balance zwischen Sicherheit und Geschwindigkeit
  const hash = await bcrypt.hash(password, 12);
  return hash; // Format: $2b$12$salt+hash (Salt ist eingebettet)
}

// Passwort verifizieren
async function verifyPassword(password, hash) {
  return await bcrypt.compare(password, hash);
}

## Python: Bcrypt mit automatischem Salting
import bcrypt

def hash_password(password: str) -> str:
    # Salt und Hash in einem Schritt generieren
    salt = bcrypt.gensalt(rounds=12)
    hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
    return hashed.decode('utf-8')

def verify_password(password: str, hash: str) -> bool:
    return bcrypt.checkpw(password.encode('utf-8'), hash.encode('utf-8'))

Wichtiger Punkt: Moderne Algorithmen (Bcrypt, Argon2, PBKDF2) verwalten Salts automatisch. Sie müssen Salts nicht manuell verwalten.

Peppering: Zusätzliche Sicherheitsschicht

Ein Pepper ist ein geheimer Wert, der getrennt von Ihrer Datenbank gespeichert wird (normalerweise in Umgebungsvariablen). Im Gegensatz zu Salts (eindeutig pro Passwort) sind Peppers für alle Passwörter gleich, bleiben aber geheim.

Stellen Sie es sich als Verteidigung in der Tiefe vor: Selbst wenn Angreifer Ihre Datenbank kompromittieren, benötigen sie immer noch den Pepper, um Passwörter zu knacken.

// Node.js: Pepper hinzufügen
const crypto = require('crypto');
const bcrypt = require('bcrypt');

const PEPPER = process.env.PASSWORD_PEPPER; // In .env speichern, niemals im Code

async function hashPasswordWithPepper(password) {
  // Pepper vor dem Hashing hinzufügen
  const pepperedPassword = password + PEPPER;
  
  // Bcrypt fügt sein eigenes Salt hinzu
  const hash = await bcrypt.hash(pepperedPassword, 12);
  return hash;
}

Wann Peppering verwenden: Es ist optional, aber für hochsichere Anwendungen empfohlen. Der Kompromiss ist Komplexität—wenn Sie den Pepper verlieren, können Sie Passwörter nicht verifizieren.

Key Stretching: Angriffe teuer machen

Key Stretching macht Hashing rechenintensiv, indem die Hash-Funktion tausende oder Millionen Male iteriert wird. Jede Passwort-Verifizierung dauert Zeit—vielleicht 200-500ms. Das ist langsam genug, um Brute-Force-Angriffe unpraktisch zu machen.

Moderne Passwort-Hashing-Algorithmen integrieren Key Stretching von Haus aus. Bcrypt verwendet einen "Cost Factor", der die Rechenzeit mit jedem Inkrement verdoppelt. Argon2 ermöglicht es Ihnen, Speicher-, Zeit- und Parallelitätskosten anzupassen.

Die Algorithmen: Was 2025 tatsächlich funktioniert

Kommen wir zur Sache. Hier sind die Algorithmen, die Sie kennen sollten, sortiert nach Sicherheit und Praktikabilität.

Bcrypt: Das bewährte Arbeitstier

Bcrypt gibt es seit 1999. Es ist der Algorithmus, den die meisten Entwickler kennen, und das aus gutem Grund: Er funktioniert. Sie können Bcrypt-Hashing mit unserem Tool Bcrypt Generator testen, um zu sehen, wie sich verschiedene Cost Factors auf die Performance auswirken.

Wie es funktioniert: Bcrypt verwendet einen Cost Factor (Work Factor), der die Iterationen bestimmt. Cost Factor 12 = 2^12 = 4.096 Iterationen. Jedes Inkrement verdoppelt die Rechenzeit.

// Node.js: Bcrypt-Implementierung
const bcrypt = require('bcrypt');

async function secureHash(password) {
  // Cost Factor 12 = gut für 2025
  // Anpassen basierend auf der Performance Ihres Servers
  const hash = await bcrypt.hash(password, 12);
  return hash;
}

async function verifyPassword(password, hash) {
  return await bcrypt.compare(password, hash);
}

# Python: Bcrypt
import bcrypt

password = "mySecurePassword123"
hashed = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt(rounds=12))

# Verifizieren
is_valid = bcrypt.checkpw(password.encode('utf-8'), hashed)

Bcrypt-Stärken:

• Bewährte Erfolgsbilanz (20+ Jahre)
• Weit verbreitet (jede Sprache hat eine Bibliothek)
• Anpassungsfähig (Cost Factor erhöhen, wenn Hardware besser wird)
• Eingebautes Salting (automatisch)

Bcrypt-Schwächen:

• GPU-anfällig (kann beschleunigt werden, obwohl immer noch langsamer als SHA-256)
• Keine Memory Hardness (ASIC-Angriffe sind möglich)
• Basiert auf Blowfish (kann mit der Zeit anfällig werden)

Ist Bcrypt 2025 noch sicher? Ja, mit Cost Factor 12 oder höher. Für neue Projekte sollten Sie Argon2 für besseren Hardware-Widerstand in Betracht ziehen. Für bestehende Systeme ist Bcrypt in Ordnung—stellen Sie nur sicher, dass Ihr Cost Factor hoch genug ist.

Argon2: Der moderne Champion

Argon2 gewann den Password Hashing Competition 2015. Es ist das, was Sicherheitsexperten für neue Projekte empfehlen. Warum? Memory Hardness.

Argon2 benötigt erheblichen RAM, um effizient zu berechnen. GPUs und ASICs haben im Vergleich zu CPUs begrenzten Speicher, was Angriffe viel teurer macht.

// Node.js: Argon2-Implementierung
const argon2 = require('argon2');

async function hashWithArgon2(password) {
  const hash = await argon2.hash(password, {
    type: argon2.argon2id, // Hybrid-Variante verwenden (empfohlen)
    memoryCost: 65536,     // 64 MB Speicher
    timeCost: 3,           // 3 Iterationen
    parallelism: 4,        // 4 Threads
  });
  return hash;
}

async function verifyArgon2(password, hash) {
  return await argon2.verify(hash, password);
}

# Python: Argon2
from argon2 import PasswordHasher

ph = PasswordHasher(
    time_cost=3,        # Anzahl der Iterationen
    memory_cost=65536,  # Speicher in KB (64 MB)
    parallelism=4,       # Anzahl der parallelen Threads
    hash_len=32,        # Hash-Länge
    salt_len=16         # Salt-Länge
)

# Passwort hashen
password = "mySecurePassword123"
hash = ph.hash(password)

# Passwort verifizieren
try:
    ph.verify(hash, password)
    print("Password is valid")
except:
    print("Password is invalid")

Argon2-Stärken:

• Memory Hardness (widersteht GPU/ASIC-Angriffen)
• Konfigurierbar (Speicher, Zeit, Parallelität anpassen)
• Modernes Design (für aktuelle Bedrohungen entwickelt)
• IETF-Standard (RFC 9106)

Argon2-Schwächen:

• Neuer (weniger bewährt als Bcrypt)
• Komplexer (erfordert Parameter-Anpassung)
• Ressourcenintensiv (kann für High-Traffic-Apps zu langsam sein)

Am besten für: Neue Anwendungen, hohe Sicherheitsanforderungen, Systeme mit reichlich Speicher.

PBKDF2: Der NIST-Standard

PBKDF2 ist NIST-zertifiziert und in Unternehmensumgebungen weit verbreitet. Es ist flexibel (Sie wählen die zugrunde liegende Hash-Funktion), erfordert aber eine sorgfältige Implementierung.

// Node.js: PBKDF2-Implementierung
const crypto = require('crypto');

function hashWithPBKDF2(password, salt) {
  // SHA-256 als zugrunde liegende Hash-Funktion verwenden
  // Minimum 100.000 Iterationen (NIST-Empfehlung)
  const iterations = 100000;
  const keyLength = 64; // 64 Bytes = 512 Bits
  
  const hash = crypto.pbkdf2Sync(
    password,
    salt,
    iterations,
    keyLength,
    'sha256'
  );
  
  // Speichern: iterations:salt:hash (alle base64-kodiert)
  return {
    iterations,
    salt: salt.toString('base64'),
    hash: hash.toString('base64')
  };
}

function verifyPBKDF2(password, storedSalt, storedHash, iterations) {
  const salt = Buffer.from(storedSalt, 'base64');
  const hash = Buffer.from(storedHash, 'base64');
  
  const computedHash = crypto.pbkdf2Sync(
    password,
    salt,
    iterations,
    hash.length,
    'sha256'
  );
  
  // Timing-sicheren Vergleich verwenden
  return crypto.timingSafeEqual(hash, computedHash);
}

PBKDF2-Stärken:

• NIST-zertifiziert (gut für Compliance)
• Flexibel (Hash-Funktion wählen)
• Gut dokumentiert

PBKDF2-Schwächen:

• Keine Memory Hardness (GPU/ASIC-anfällig)
• Manuelle Implementierung (müssen Salts selbst verwalten)
• Weniger effizient (langsamer als Bcrypt bei gleicher Sicherheit)

Am besten für: Unternehmensanwendungen, Compliance-Anforderungen, Systeme, die NIST-Standards benötigen.

SHA-256 und SHA-512: Warum sie für Passwörter falsch sind

SHA-256 und SHA-512 sind kryptografische Hash-Funktionen, aber sie sind nicht für Passwort-Hashing entwickelt. Sie sind schnell—zu schnell für Sicherheit.

// Node.js: SHA-256 (NICHT EMPFOHLEN für Passwörter)
const crypto = require('crypto');

function hashWithSHA256(password) {
  // Das ist SCHNELL - Angreifer können Milliarden pro Sekunde berechnen
  return crypto.createHash('sha256').update(password).digest('hex');
}

// Ein Angreifer kann Millionen von Passwörtern pro Sekunde ausprobieren
// Deshalb ist SHA-256 für Passwort-Speicherung unsicher

Ist SHA-256 sicher? Für Datenintegrität, ja. Für Passwort-Hashing, absolut nicht. SHA-256 kann über 1 Milliarde Hashes pro Sekunde auf moderner Hardware berechnen. Ihr Passwort? In Minuten geknackt.

Wann SHA-256 akzeptabel ist: Wenn es mit PBKDF2 als zugrunde liegende Hash-Funktion verwendet wird, oder für Datenintegritätsprüfungen. Niemals direkt für Passwörter verwenden.

scrypt: Die Memory-Hard-Alternative

scrypt ist wie Argon2 Memory-Hard, aber älter. Es wird von vielen Kryptowährungssystemen verwendet.

// Node.js: scrypt-Implementierung
const crypto = require('crypto');

function hashWithScrypt(password, salt) {
  const keyLength = 64;
  const cost = 16384;      // CPU/Speicher-Kostenparameter (2^14)
  const blockSize = 8;     // Blockgrößenparameter
  const parallelization = 1; // Parallelisierungsparameter
  
  const hash = crypto.scryptSync(
    password,
    salt,
    keyLength,
    {
      cost,
      blockSize,
      parallelization
    }
  );
  
  return {
    cost,
    blockSize,
    parallelization,
    salt: salt.toString('base64'),
    hash: hash.toString('base64')
  };
}

Am besten für: Systeme, die bereits scrypt verwenden, Kryptowährungsanwendungen.

Algorithmus-Vergleich: Die 2025-Realitätsprüfung

Möchten Sie diese Algorithmen testen? Verwenden Sie unseren Hash Generator, um SHA-256, SHA-512 und MD5 zu vergleichen (für Datenintegrität, nicht für Passwörter!), oder unseren Bcrypt Generator, um Bcrypt-Hashing mit verschiedenen Cost Factors zu testen.

Performance-Benchmarks (2025-Hardware)

• SHA-256: ~1 Milliarde Hashes/Sekunde
• SHA-512: ~500 Millionen Hashes/Sekunde
• PBKDF2-SHA256 (100k Iterationen): ~1.000 Hashes/Sekunde
• Bcrypt (cost 12): ~100 Hashes/Sekunde
• Argon2id (t=3, m=64MB): ~50 Hashes/Sekunde
• scrypt (N=16384): ~30 Hashes/Sekunde

Best Practices: Was tatsächlich funktioniert

Hier ist, was ich aus dem Aufbau sicherer Systeme und dem Sehen, was in der Produktion kaputt geht, gelernt habe.

1. Wählen Sie den richtigen Algorithmus

Für neue Projekte: Verwenden Sie Argon2id mit diesen Parametern:

• Speicherkosten: 64 MB (65536 KB)
• Zeitkosten: 3 Iterationen
• Parallelität: 4 Threads

Für bestehende Projekte: Bcrypt mit Cost Factor 12+ ist noch sicher. Erwägen Sie die Migration zu Argon2, wenn Sie eine größere Überarbeitung durchführen.

Für Unternehmen/Compliance: PBKDF2 mit SHA-256, 100.000+ Iterationen.

2. Verwenden Sie immer Salts

Haschen Sie niemals Passwörter ohne Salts. Moderne Algorithmen handhaben dies automatisch, aber wenn Sie manuell implementieren:

• Verwenden Sie kryptografisch zufällige Salts
• Eindeutiges Salt pro Passwort
• Speichern Sie Salts zusammen mit Hashes

3. Setzen Sie angemessene Cost Factors

Testen Sie auf Ihrer tatsächlichen Hardware. Ziel: 200-500ms pro Hash:

// Node.js: Adaptiver Cost Factor
const bcrypt = require('bcrypt');

async function benchmarkBcrypt() {
  const testPassword = "testPassword123";
  const start = Date.now();
  
  await bcrypt.hash(testPassword, 12);
  
  const duration = Date.now() - start;
  
  // Ziel: 200-500ms pro Hash
  if (duration < 200) {
    return 13; // Cost erhöhen
  } else if (duration > 500) {
    return 11; // Cost verringern
  }
  return 12; // Optimal
}

4. Verwenden Sie Timing-sicheren Vergleich

Verhindern Sie Timing-Angriffe mit konstantzeitlichem Vergleich:

// Node.js: Timing-sicherer Vergleich
const crypto = require('crypto');

function timingSafeEqual(a, b) {
  if (a.length !== b.length) {
    return false;
  }
  return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
}

5. Implementieren Sie Rate Limiting

Schützen Sie Authentifizierungs-Endpunkte:

// Beispiel: Express.js Rate Limiting
const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 Minuten
  max: 5, // 5 Versuche pro Fenster
  message: 'Zu viele Login-Versuche, bitte versuchen Sie es später erneut.'
});

6. Speichern Sie Hashes sicher

• Niemals Passwort-Hashes loggen
• Verwenden Sie Umgebungsvariablen für Peppers
• Verschlüsseln Sie Datenbank-Backups
• Implementieren Sie ordnungsgemäße Zugriffskontrollen

7. Planen Sie Algorithmus-Migration

Entwerfen Sie Ihr System so, dass Upgrades möglich sind:

// Node.js: Algorithmus-agnostische Verifizierung
async function verifyPassword(password, storedHash) {
  // Algorithmus aus Hash-Format erkennen
  if (storedHash.startsWith('$2b$') || storedHash.startsWith('$2a$')) {
    // Bcrypt
    return await bcrypt.compare(password, storedHash);
  } else if (storedHash.startsWith('$argon2id$')) {
    // Argon2
    return await argon2.verify(storedHash, password);
  } else {
    // Legacy oder unbekannt - Rehash auslösen
    throw new Error('Nicht unterstützter Hash-Algorithmus');
  }
}

Implementierung in der Praxis

Hier ist ein vollständiges Authentifizierungssystem, das Sie verwenden können:

// auth.js - Vollständige Passwort-Hashing-Implementierung
const bcrypt = require('bcrypt');

class PasswordManager {
  constructor(costFactor = 12) {
    this.costFactor = costFactor;
  }

  async hashPassword(password) {
    return await bcrypt.hash(password, this.costFactor);
  }

  async verifyPassword(password, hash) {
    if (hash.startsWith('$2')) {
      return await bcrypt.compare(password, hash);
    }
    throw new Error('Ungültiges Hash-Format');
  }

  async needsRehash(hash) {
    if (hash.startsWith('$2b$')) {
      const rounds = parseInt(hash.split('$')[2]);
      return rounds < this.costFactor;
    }
    return true; // Unbekanntes Format, sollte rehashen
  }
}

// Verwendung
const passwordManager = new PasswordManager(12);

async function registerUser(email, password) {
  const hash = await passwordManager.hashPassword(password);
  
  // In Datenbank speichern
  await db.users.insert({
    email,
    passwordHash: hash,
    createdAt: new Date()
  });
}

async function authenticateUser(email, password) {
  const user = await db.users.findOne({ email });
  
  if (!user) {
    return false;
  }

  const isValid = await passwordManager.verifyPassword(
    password,
    user.passwordHash
  );

  // Hash aktualisieren, falls nötig (schrittweise Migration)
  if (isValid && await passwordManager.needsRehash(user.passwordHash)) {
    const newHash = await passwordManager.hashPassword(password);
    await db.users.update(
      { email },
      { passwordHash: newHash }
    );
  }

  return isValid;
}

Häufige Fehler (Machen Sie das nicht)

Schnelle Hash-Funktionen verwenden

// FALSCH - Zu schnell!
const hash = crypto.createHash('sha256').update(password).digest('hex');

Salts wiederverwenden

// FALSCH - Gleiches Salt für alle Passwörter
const salt = 'fixedSalt123';

Klartext speichern

// FALSCH - Niemals das tun!
await db.users.insert({ email, password: plaintextPassword });

Unzureichende Cost Factors

// FALSCH - Zu niedrig!
const hash = await bcrypt.hash(password, 4);

Ihre Implementierung testen

Verwenden Sie unsere Tools, um Ihre Implementierungen zu testen und zu verifizieren:

• Bcrypt Generator - Bcrypt-Hashes mit verschiedenen Cost Factors generieren und verifizieren
• Hash Generator - SHA-256, SHA-512, MD5 testen (für Datenintegrität, nicht für Passwörter!)
• Password Strength Checker - Sicherstellen, dass Benutzer starke Passwörter erstellen, bevor sie gehasht werden

Pro-Tipp: Testen Sie Ihre Passwort-Hashing-Implementierung mit unserem Bcrypt Generator, um verschiedene Cost Factors zu benchmarken und das optimale Gleichgewicht zwischen Sicherheit und Performance für Ihre Hardware zu finden.

Häufig gestellte Fragen

Ist Bcrypt 2025 noch sicher?

Ja, Bcrypt bleibt sicher mit Cost Factor 12 oder höher. Argon2id bietet besseren Hardware-Widerstand, aber Bcrypt ist für die meisten Anwendungen in Ordnung.

Bcrypt vs Argon2: Was sollte ich verwenden?

Verwenden Sie Argon2id für neue Projekte (besserer Hardware-Widerstand). Bcrypt ist noch sicher und kann für Kompatibilität oder bestehende Systeme vorzuziehen sein.

Ist SHA-256 sicher für Passwörter?

Nein, verwenden Sie SHA-256 niemals direkt für Passwörter. Es ist zu schnell. Verwenden Sie es mit PBKDF2 oder verwenden Sie stattdessen Bcrypt/Argon2.

Was ist der beste Passwort-Hashing-Algorithmus 2025?

Argon2id ist die beste Wahl für neue Anwendungen. Es bietet Memory Hardness, konfigurierbare Parameter und modernes Design.

Wie speichere ich Passwörter sicher?

1. Verwenden Sie Argon2id (neu) oder Bcrypt (bestehend)
2. Verwenden Sie immer Salts (automatisch mit modernen Algorithmen)
3. Setzen Sie angemessene Cost Factors
4. Implementieren Sie Rate Limiting
5. Verwenden Sie Timing-sicheren Vergleich
6. Planen Sie Algorithmus-Migration

Was ist Hashing und Salting von Passwörtern?

Hashing konvertiert Passwörter in feste Längen-Strings, die nicht umkehrbar sind. Salting fügt jedem Passwort vor dem Hashing zufällige Daten hinzu, sodass identische Passwörter unterschiedliche Hashes produzieren.

Kann ich MD5 für Passwort-Hashing verwenden?

Nein, MD5 ist kryptografisch gebrochen. Angreifer können Milliarden von MD5-Hashes pro Sekunde berechnen. Verwenden Sie es niemals für Passwörter.

Was ist Memory Hardness?

Memory Hardness macht einen Algorithmus so, dass er erheblichen RAM benötigt, um effizient zu berechnen. Algorithmen mit Memory Hardness (Argon2, scrypt) widerstehen GPU/ASIC-Angriffen.

🔄 Aktualisiert für 2025

Dieser Leitfaden wurde aktualisiert, um die neuesten Sicherheitsempfehlungen und Hardware-Fähigkeiten 2025 widerzuspiegeln.

Hardware-Verbesserungen

Moderne GPUs und ASICs sind seit 2020 erheblich leistungsfähiger geworden. Eine einzelne High-End-GPU kann jetzt berechnen:

• SHA-256: Über 2 Milliarden Hashes/Sekunde (von ~1 Milliarde)
• Bcrypt (cost 10): ~500 Hashes/Sekunde (von ~200)
• Argon2id: Immer noch resistent aufgrund von Speicheranforderungen

GPU-Cracking-Geschwindigkeiten

Angreifer können jetzt schwache Passwörter schneller als je zuvor knacken:

• SHA-256-Passwörter: In Sekunden geknackt (auch mit Salts)
• Bcrypt (cost 8): Anfällig für GPU-Angriffe
• Bcrypt (cost 12+): Immer noch sicher, aber erwägen Sie ein Upgrade auf cost 13-14

Neue Argon2-Empfehlungen

Das IETF hat Argon2-Empfehlungen für 2025 aktualisiert:

• Speicherkosten: 64-128 MB (von 32-64 MB)
• Zeitkosten: 3-4 Iterationen (von 2-3)
• Parallelität: 4-8 Threads (abhängig von Serverkapazität)

Was das für Sie bedeutet

1. Bestehende Bcrypt-Systeme: Erhöhen Sie den Cost Factor auf 13-14, wenn möglich
2. Neue Projekte: Verwenden Sie Argon2id mit aktualisierten Parametern
3. Hochsichere Anwendungen: Erwägen Sie Argon2id mit 128 MB Speicherkosten
4. Rate Limiting: Wichtiger als je zuvor—implementieren Sie strenge Limits

Testen Sie Ihr aktuelles Setup: Verwenden Sie unseren Bcrypt Generator, um Ihre aktuellen Cost Factors zu benchmarken und zu sehen, ob sie den 2025-Sicherheitsstandards entsprechen.

Fazit

Passwortsicherheit 2025 ist nicht kompliziert—es geht darum, den richtigen Algorithmus zu wählen und ihn korrekt zu implementieren.

Das Wichtigste:

• Verwenden Sie Argon2id für neue Projekte
• Verwenden Sie Bcrypt (cost 12+) für bestehende Systeme
• Verwenden Sie niemals SHA-256 oder MD5 direkt für Passwörter
• Verwenden Sie immer Salts (automatisch mit modernen Algorithmen)
• Setzen Sie angemessene Cost Factors basierend auf Ihrer Hardware

Bleiben Sie sicher und viel Erfolg beim Programmieren!