Verwendung eines gebrochenen oder riskanten kryptografischen Algorithmus

Beschreibung

Verwendung eines gebrochenen oder riskanten kryptografischen Algorithmus tritt auf, wenn Software kryptografische Algorithmen oder Protokolle verwendet, die bekannte Schwächen haben, veraltet sind oder für den Sicherheitskontext ungeeignet sind. Dies umfasst die Verwendung veralteter Hash-Funktionen (MD5, SHA-1), schwacher Verschlüsselungsalgorithmen (DES, RC4), gebrochener Protokolle (SSLv2, SSLv3), unzureichender Schlüssellängen, schwacher Zufallszahlengeneratoren oder selbst entwickelter Kryptografie. Wenn kryptografischer Schutz versagt, werden Datenvertraulichkeit, Integrität und Authentifizierung kompromittiert, was möglicherweise sensible Informationen Angreifern offenlegt.

Risiko

Schwache Kryptografie bietet falsche Sicherheit - Systeme erscheinen geschützt, können aber gebrochen werden. MD5- und SHA-1-Kollisionen wurden praktisch demonstriert, was gefälschte Zertifikate und Dokumentenmanipulation ermöglicht. DES kann in Stunden per Brute-Force geknackt werden. RC4 hat statistische Verzerrungen, die Klartext-Wiederherstellung ermöglichen. A5/1/A5/2-Mobilfunkverschlüsselung wurde gebrochen, was Echtzeit-Abfangen von Mobilgesprächen mit kommerziellen Tools ermöglicht. Historische Sicherheitsverletzungen resultierten aus dem Vertrauen auf veraltete Algorithmen, die bei der Bereitstellung "gut genug" waren, aber später anfällig wurden. OWASP stuft Kryptografische Fehler als #2 in ihren Top 10 ein.

Lösung

Verwenden Sie nur aktuelle, gut geprüfte kryptografische Algorithmen. Für Verschlüsselung: AES-256-GCM oder ChaCha20-Poly1305. Für Hashing: SHA-256, SHA-3 oder BLAKE2. Für Passwort-Hashing: Argon2, bcrypt oder scrypt. Für Schlüsselaustausch: ECDH mit P-256 oder X25519. Verwenden Sie TLS 1.2+ mit starken Cipher Suites. Implementieren Sie niemals benutzerdefinierte Kryptografie. Verwenden Sie etablierte Bibliotheken (OpenSSL, libsodium, BoringSSL). Folgen Sie NIST-Richtlinien und Industriestandards. Implementieren Sie kryptografische Agilität, um Algorithmusaktualisierungen zu ermöglichen. Prüfen Sie kryptografische Implementierungen regelmäßig.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Umfang: Datenoffenlegung Schwache Verschlüsselung kann gebrochen werden, wodurch alle geschützten Daten Angreifern offengelegt werden.
Integrität	Umfang: Fälschung Gebrochene Hash-Algorithmen ermöglichen Kollisionsangriffe, die gefälschte Dokumente, Zertifikate und Signaturen ermöglichen.
Authentifizierung	Umfang: Anmeldedaten-Diebstahl Schwaches Passwort-Hashing oder Authentifizierungsprotokolle legen Benutzeranmeldedaten offen.

Beispielcode + Korrigierter Code

Anfälliger Code

// ANFÄLLIG: MD5 für Passwort-Hashing
import java.security.MessageDigest;

public String hashPassword(String password) {
    MessageDigest md = MessageDigest.getInstance("MD5");  // Gebrochen!
    byte[] hash = md.digest(password.getBytes());
    return Base64.getEncoder().encodeToString(hash);
}

// ANFÄLLIG: DES-Verschlüsselung
import javax.crypto.Cipher;

public byte[] encrypt(byte[] data, Key key) {
    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");  // Schwach!
    cipher.init(Cipher.ENCRYPT_MODE, key);
    return cipher.doFinal(data);
}

// ANFÄLLIG: SHA-1 für Signaturen
MessageDigest sha1 = MessageDigest.getInstance("SHA-1");  // Kollisionsangriffe!

# ANFÄLLIG: MD5 für Integritätsprüfung
import hashlib

def verify_file(filepath, expected_hash):
    md5 = hashlib.md5()  # Gebrochen - Kollisionen möglich!
    with open(filepath, 'rb') as f:
        md5.update(f.read())
    return md5.hexdigest() == expected_hash

# ANFÄLLIG: Schwacher Zufall für Tokens
import random
def generate_token():
    return str(random.randint(0, 999999))  # Vorhersagbar!

// ANFÄLLIG: Schwache Kryptografie in Node.js
const crypto = require('crypto');

// RC4 ist gebrochen
const cipher = crypto.createCipheriv('rc4', key, '');

// DES ist schwach
const desCipher = crypto.createCipheriv('des', key, iv);

// MD5 zur Verifizierung
const hash = crypto.createHash('md5').update(data).digest('hex');

Korrigierter Code

// SICHER: Modernes Passwort-Hashing mit Argon2
import org.bouncycastle.crypto.generators.Argon2BytesGenerator;
import org.bouncycastle.crypto.params.Argon2Parameters;

public String hashPasswordSafe(String password) {
    Argon2Parameters params = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
        .withMemoryAsKB(65536)
        .withIterations(3)
        .withParallelism(4)
        .withSalt(generateSecureSalt())
        .build();

    Argon2BytesGenerator generator = new Argon2BytesGenerator();
    generator.init(params);
    byte[] hash = new byte[32];
    generator.generateBytes(password.toCharArray(), hash);
    return Base64.getEncoder().encodeToString(hash);
}

// SICHER: AES-256-GCM-Verschlüsselung
public byte[] encryptSafe(byte[] data, SecretKey key) throws Exception {
    Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
    byte[] iv = new byte[12];  // 96-Bit IV für GCM
    SecureRandom.getInstanceStrong().nextBytes(iv);

    cipher.init(Cipher.ENCRYPT_MODE, key, new GCMParameterSpec(128, iv));
    byte[] ciphertext = cipher.doFinal(data);

    // IV dem Geheimtext voranstellen
    byte[] result = new byte[iv.length + ciphertext.length];
    System.arraycopy(iv, 0, result, 0, iv.length);
    System.arraycopy(ciphertext, 0, result, iv.length, ciphertext.length);
    return result;
}

// SICHER: SHA-256 für Integrität
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");

# SICHER: Modernes Passwort-Hashing
from argon2 import PasswordHasher

ph = PasswordHasher()

def hash_password_safe(password):
    return ph.hash(password)

def verify_password_safe(hash, password):
    try:
        return ph.verify(hash, password)
    except:
        return False

# SICHER: SHA-256 für Integrität
import hashlib

def verify_file_safe(filepath, expected_hash):
    sha256 = hashlib.sha256()
    with open(filepath, 'rb') as f:
        for chunk in iter(lambda: f.read(8192), b''):
            sha256.update(chunk)
    return sha256.hexdigest() == expected_hash

# SICHER: Kryptografisch sicherer Zufall
import secrets

def generate_token_safe():
    return secrets.token_urlsafe(32)  # 256 Bits Entropie

// SICHER: Moderne Kryptografie in Node.js
const crypto = require('crypto');

// AES-256-GCM
function encrypt(plaintext, key) {
    const iv = crypto.randomBytes(12);
    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);

    let encrypted = cipher.update(plaintext, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    const authTag = cipher.getAuthTag();

    return { iv: iv.toString('hex'), encrypted, authTag: authTag.toString('hex') };
}

// SHA-256 für Hashing
const hash = crypto.createHash('sha256').update(data).digest('hex');

// Sichere zufällige Tokens
const token = crypto.randomBytes(32).toString('hex');

---

Ausgenutzt in der Praxis

A5/1 GSM-Verschlüsselung (Mobilfunk, laufend)

A5/1- und A5/2-Mobilfunkverschlüsselungsalgorithmen sind kryptanalytisch gebrochen. Kommerzielle Tools existieren, um Mobiltelefongespräche in Echtzeit mit gefälschten Basisstationen abzufangen und zu entschlüsseln.

• https://www.computerworld.com/article/2756631/

SHA-1-Kollision (SHAttered, 2017)

Google und CWI Amsterdam demonstrierten praktische SHA-1-Kollisionen und erstellten zwei verschiedene PDF-Dateien mit demselben SHA-1-Hash. Dies ermöglicht Zertifikatsfälschung und Dokumentenmanipulation.

• https://shattered.io/

MD5-Zertifikatsfälschung (Flame-Malware, 2012)

Die Flame-Malware verwendete MD5-Kollisionsangriffe, um Microsoft-Zertifikate zu fälschen, was Code-Signierung mit scheinbar legitimen Microsoft-Signaturen ermöglichte.

• https://www.cwi.nl/news/2012/flame-espionage-malware-uses-md5-collision-attack

---

Tools zum Testen/Ausnutzen

• HashClash — MD5- und SHA-1-Kollisionsgenerator.

• SSLyze — Identifiziert schwache TLS-Konfigurationen.

• CryptoLyzer — Analysator für kryptografische Protokolle.

---

CVE-Beispiele

• CVE-2019-6111 — SCP-Client verwendet schwache Krypto-Validierung.

• CVE-2022-21449 — Java ECDSA-Signaturvalidierungs-Bypass.

• CVE-2020-0601 — Windows CryptoAPI-Zertifikatsvalidierung (CurveBall).

---

Referenzen

1. MITRE. "CWE-327: Use of a Broken or Risky Cryptographic Algorithm." https://cwe.mitre.org/data/definitions/327.html

2. OWASP. "A02:2021 – Cryptographic Failures." https://owasp.org/Top10/A02_2021-Cryptographic_Failures/

3. NIST. "Cryptographic Standards and Guidelines." https://csrc.nist.gov/Projects/Cryptographic-Standards-and-Guidelines