Klartext-Speicherung sensibler Informationen

Beschreibung

Klartext-Speicherung sensibler Informationen tritt auf, wenn ein Produkt sensible Informationen im Klartext in einer Ressource speichert, die möglicherweise für eine andere Kontrollsphäre zugänglich ist. Sensible Daten wie Passwörter, persönliche Identifikationsnummern, kryptografische Schlüssel, Kreditkartennummern und persönliche Gesundheitsinformationen müssen bei der Speicherung geschützt werden. Wenn diese Daten ohne Verschlüsselung oder Hashing gespeichert werden, sind sie für jeden zugänglich, der Lesezugriff auf das Speichermedium erhält - sei es durch legitimen Zugriff auf Backups, Log-Dateien, Konfigurationsdateien, Datenbanken oder durch unbefugten Zugriff via Ausnutzung anderer Schwachstellen.

Risiko

Klartext-Speicherungs-Schwachstellen haben zu massiven Datenlecks beigetragen, die Millionen von Datensätzen exponiert haben. Wenn Angreifer ein System kompromittieren, ermöglicht das Auffinden von Klartext-Anmeldedaten sofortige laterale Bewegung und Privilegieneskalation. Datenbankexporte mit unverschlüsselten Passwörtern exponieren alle Benutzer für Credential-Stuffing-Angriffe bei anderen Diensten. Schneider Electrics CVE-2024-8070 exponierte Test-Anmeldedaten in Firmware-Binärdateien. Jenkins OpenShift Pipeline-Plugin und Microsoft PC Manager hatten beide Klartext-Speicherungsprobleme in 2025. Cloud-Orchestrierungstools wie Canonical Juju haben private Schlüssel exponiert. Diese Schwachstellen verletzen Compliance-Anforderungen (PCI-DSS, HIPAA, DSGVO) und führen zu regulatorischen Strafen.

Lösung

Verschlüsseln Sie sensible Informationen im Ruhezustand mit starken, branchenüblichen Algorithmen (AES-256). Verwenden Sie ordnungsgemäßes Schlüsselmanagement mit Hardware-Sicherheitsmodulen (HSM) für Schlüsselspeicherung. Hashen Sie Passwörter mit modernen Algorithmen (Argon2, bcrypt, scrypt) anstatt sie zu verschlüsseln. Implementieren Sie ordnungsgemäße Zugriffskontrollen auf Speicherorte. Vermeiden Sie das Protokollieren sensibler Informationen. Verschlüsseln Sie Datenbankspalten, die PII enthalten. Verschlüsseln Sie Backups und konfigurieren Sie ordnungsgemäße Zugriffskontrollen. Verwenden Sie Secrets-Management-Lösungen (HashiCorp Vault, AWS Secrets Manager) für Anmeldedaten. Führen Sie regelmäßige Audits durch, um Klartext-Speicherung zu identifizieren.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Datenexposition Sensible Informationen, die im Klartext gespeichert sind, sind direkt von Angreifern lesbar, die Zugriff auf Speicher erhalten.
Authentifizierung	Bereich: Credential-Diebstahl Klartext-Passwörter ermöglichen sofortige Kontokompromittierung und laterale Bewegung.
Compliance	Bereich: Regulatorische Verstöße Klartext-Speicherung von PII oder Karteninhaberdaten verletzt PCI-DSS-, HIPAA- und DSGVO-Anforderungen.

Beispielcode + Korrigierter Code

Anfälliger Code

# ANFÄLLIG: Passwörter im Klartext speichern
import sqlite3

def create_user(username, password):
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    # Passwort als Klartext gespeichert - jeder mit DB-Zugriff kann es lesen!
    cursor.execute("INSERT INTO users (username, password) VALUES (?, ?)",
                   (username, password))
    conn.commit()

# ANFÄLLIG: Anmeldedaten in Konfigurationsdatei
config = {
    'database_host': 'localhost',
    'database_user': 'admin',
    'database_password': 'SuperSecret123!',  # Klartext in Konfiguration!
    'api_key': 'sk-1234567890abcdef'  # API-Schlüssel exponiert!
}

// ANFÄLLIG: Sensible Informationen protokollieren
import java.util.logging.Logger;

public class UserService {
    private static final Logger logger = Logger.getLogger(UserService.class.getName());

    public void login(String username, String password) {
        // Passwörter im Klartext protokolliert!
        logger.info("Anmeldeversuch für Benutzer: " + username + " mit Passwort: " + password);

        // Passwort im Klartext in Session gespeichert
        session.setAttribute("password", password);
    }
}

// ANFÄLLIG: Token ohne Verschlüsselung in localStorage speichern
function saveAuthToken(token) {
    // Token als Klartext gespeichert - XSS kann es stehlen
    localStorage.setItem('authToken', token);
    localStorage.setItem('refreshToken', refreshToken);
}

// ANFÄLLIG: Anmeldedaten in Umgebung/Konfiguration
const config = {
    awsSecretKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
    stripeApiKey: 'sk_live_1234567890abcdef'
};

Korrigierter Code

# SICHER: Passwort-Hashing mit Argon2
from argon2 import PasswordHasher
from cryptography.fernet import Fernet
import os

ph = PasswordHasher()

def create_user_safe(username, password):
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    # Passwort hashen - kann nicht umgekehrt werden
    password_hash = ph.hash(password)
    cursor.execute("INSERT INTO users (username, password_hash) VALUES (?, ?)",
                   (username, password_hash))
    conn.commit()

def verify_password_safe(stored_hash, provided_password):
    try:
        return ph.verify(stored_hash, provided_password)
    except:
        return False

# SICHER: Sensible Konfiguration verschlüsseln
def load_encrypted_config():
    key = os.environ.get('CONFIG_ENCRYPTION_KEY')  # Schlüssel aus sicherer Quelle
    fernet = Fernet(key)

    with open('config.encrypted', 'rb') as f:
        encrypted_data = f.read()

    decrypted_config = fernet.decrypt(encrypted_data)
    return json.loads(decrypted_config)

// SICHER: Keine sensiblen Daten in Logs, verschlüsselte Session-Daten
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;

public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    private final SecretKey encryptionKey;

    public void login(String username, String password) {
        // Niemals Passwörter protokollieren
        logger.info("Anmeldeversuch für Benutzer: {}", username);

        // Passwort für Speicherung hashen, bei Bedarf für Session verschlüsseln
        String passwordHash = BCrypt.hashpw(password, BCrypt.gensalt(12));

        // Passwort so schnell wie möglich aus dem Speicher löschen
        Arrays.fill(password.toCharArray(), '\0');
    }

    private byte[] encryptSessionData(String data) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, encryptionKey);
        return cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
    }
}

// SICHER: Verschlüsselte Speicherung mit sicherem Schlüsselmanagement
const crypto = require('crypto');

class SecureStorage {
    constructor(encryptionKey) {
        this.key = Buffer.from(encryptionKey, 'hex');
    }

    encrypt(plaintext) {
        const iv = crypto.randomBytes(12);
        const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv);
        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
        encrypted += cipher.final('hex');
        const authTag = cipher.getAuthTag();
        return iv.toString('hex') + ':' + authTag.toString('hex') + ':' + encrypted;
    }

    decrypt(ciphertext) {
        const [ivHex, authTagHex, encrypted] = ciphertext.split(':');
        const iv = Buffer.from(ivHex, 'hex');
        const authTag = Buffer.from(authTagHex, 'hex');
        const decipher = crypto.createDecipheriv('aes-256-gcm', this.key, iv);
        decipher.setAuthTag(authTag);
        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
        decrypted += decipher.final('utf8');
        return decrypted;
    }
}

// Umgebungsvariablen für Anmeldedaten verwenden (aus sicherem Secrets Manager geladen)
const config = {
    awsSecretKey: process.env.AWS_SECRET_KEY,  // Aus Secrets Manager
    stripeApiKey: process.env.STRIPE_API_KEY
};

---

Ausgenutzt in der Praxis

Schneider Electric Firmware (Schneider Electric, 2024)

CVE-2024-8070 in Schneider Electric-Produkten exponierte Test-Anmeldedaten, die im Klartext in Firmware-Binärdateien gespeichert waren, was Angreifern mit Zugriff auf Firmware ermöglichte, Authentifizierungs-Credentials zu extrahieren.

• https://www.cvedetails.com/cve/CVE-2024-8070/

Canonical Juju Private Keys (Canonical, 2025)

CVE-2025-6224 in Canonical Juju Utils exponierte private Schlüssel, die während Speicherung und Übertragung unzureichend geschützt waren, was Angreifern ermöglichte, kryptografische Schlüssel zu extrahieren und unbefugten Zugriff auf Cloud-Dienste zu erlangen.

• https://radar.offseq.com/

Jenkins OpenShift Pipeline Plugin (Jenkins, 2025)

Klartext-Speicherungs-Schwachstelle für sensible Informationen im Jenkins OpenShift Pipeline-Plugin exponierte Anmeldedaten, die von Benutzern mit Zugriff auf Jenkins-Konfigurationsdateien abgerufen werden könnten.

• https://www.jenkins.io/security/

---

Tools zum Testen/Ausnutzen

• TruffleHog — Nach Secrets in Code-Repositories scannen.

• GitLeaks — Hartcodierte Secrets in Git-Repos erkennen.

• Secrets Scanner — Secrets in Codebasen erkennen.

---

CVE-Beispiele

• CVE-2024-8070 — Schneider Electric Klartext-Anmeldedaten in Firmware.

• CVE-2025-6224 — Canonical Juju Klartext-Speicherung privater Schlüssel.

• CVE-2019-13945 — Siemens S7-1200 CPU Passwortspeicherung im Klartext.

---

Referenzen

1. MITRE. "CWE-312: Cleartext Storage of Sensitive Information." https://cwe.mitre.org/data/definitions/312.html

2. OWASP. "Password Storage Cheat Sheet." https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html