Base64 Sicherheits-Best-Practices

// BASE64 IST KEINE VERSCHLÜSSELUNG

Das kritischste Sicherheitsmissverständnis ist die Behandlung von Base64 als Verschlüsselung. Base64 ist lediglich Kodierung - es ist vollständig umkehrbar ohne jeden Schlüssel oder Passwort.

Jeder kann Base64-Daten sofort dekodieren. Verlassen Sie sich niemals auf Base64 für Sicherheit oder Datenschutz.

// ❌ FALSCH: Base64 als 'Sicherheit' verwenden
const password = 'geheim123';
const encoded = btoa(password); // Z2VoZWltMTIz
// Jeder kann das sofort dekodieren!

// ✅ RICHTIG: Ordnungsgemäßes Passwort-Hashing
import bcrypt from 'bcrypt';
const password = 'geheim123';
const hashedPassword = await bcrypt.hash(password, 12);
// Das ist tatsächlich sicher

// EINGABEVALIDIERUNG

Validieren Sie immer Base64-Eingaben, um Injection-Angriffe und Anwendungsfehler zu verhindern:

Ordnungsgemäße Validierung verhindert, dass bösartige Eingaben Sicherheitsprobleme oder Anwendungsabstürze verursachen.

// Base64-Format validieren
function isValidBase64(str) {
    // Format prüfen: nur gültige Base64-Zeichen
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Länge prüfen (muss Vielfaches von 4 sein)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Dekodierung testen
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Sichere Dekodierung mit Validierung
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Eingabe muss ein String sein');
    }
    
    if (input.length > maxLength) {
        throw new Error('Eingabe zu lang');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Ungültiges Base64');
    }
    
    return atob(input);
}

// XSS-PRÄVENTION

Base64-Daten können bösartige Skripte enthalten, wenn sie dekodiert werden. Bereinigen Sie immer die Ausgabe beim Anzeigen dekodierter Inhalte:

Vertrauen Sie niemals Base64-Eingaben von Benutzern. Bereinigen Sie immer vor dem Rendern in HTML.

// ❌ GEFÄHRLICH: Direkte HTML-Injection
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // XSS-Schwachstelle!
}

// ✅ SICHER: Ausgabe bereinigen
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Textknoten erstellen (keine HTML-Ausführung)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // Oder HTML-Entitäten escapen
    const escaped = decoded
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// GRÖSSENBESCHRÄNKUNGEN

Base64-Kodierung erhöht die Datengröße um etwa 33%. Implementieren Sie Größenbeschränkungen, um DoS-Angriffe zu verhindern:

Unbeschränkte Base64-Eingaben können übermäßigen Speicher und Rechenleistung verbrauchen.

> Maximale Eingabelängenlimits festlegen
> Speicherverbrauch während der Verarbeitung überwachen
> Timeouts für lange Operationen implementieren
> Streaming für große Datensätze verwenden
> Komprimierung vor Kodierung erwägen
> Base64-Operationen ratenbegrenzen

// SICHERE TOKEN-BEHANDLUNG

Bei der Verwendung von Base64 für Token oder sensitive IDs folgen Sie Sicherheits-Best-Practices:

Ordnungsgemäße Token-Behandlung verhindert unbefugten Zugriff und token-basierte Angriffe.

// Sicheres Token erstellen
function createSecureToken() {
    // Kryptographisch sichere Zufallswerte verwenden
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Zu Base64 konvertieren und URL-sicher machen
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Sichere Token-Validierung
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Länge prüfen
    if (token.length !== expectedLength) {
        return false;
    }
    
    // URL-sicheres Base64-Format prüfen
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATEN-URI-SICHERHEIT

Base64-Daten-URIs können bösartigen Inhalt enthalten. Validieren und bereinigen Sie immer Daten-URIs:

Bösartige Daten-URIs können Skripte ausführen, externe Ressourcen laden oder unangemessenen Inhalt enthalten.

// Daten-URI validieren
function validateDataURI(dataUri, allowedTypes = ['image/png', 'image/jpeg']) {
    const dataUriRegex = /^data:([a-zA-Z0-9][a-zA-Z0-9\/+]*);base64,(.+)$/;
    const match = dataUri.match(dataUriRegex);
    
    if (!match) {
        throw new Error('Ungültiges Daten-URI-Format');
    }
    
    const [, mimeType, base64Data] = match;
    
    // MIME-Typ validieren
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Nicht unterstützter MIME-Typ: ${mimeType}`);
    }
    
    // Base64-Daten validieren
    if (!isValidBase64(base64Data)) {
        throw new Error('Ungültiges Base64 in Daten-URI');
    }
    
    // Größe prüfen
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // 1MB Limit
        throw new Error('Daten-URI zu groß');
    }
    
    return { mimeType, base64Data };
}

// SICHERE IMPLEMENTIERUNGS-CHECKLISTE

> Niemals Base64 als Verschlüsselung oder Sicherheitsmaßnahme verwenden
> Immer Base64-Eingabeformat und -länge validieren
> Dekodierte Ausgabe vor Anzeige bereinigen
> Größenlimits und Timeouts implementieren
> URL-sicheres Base64 für Webanwendungen verwenden
> MIME-Typen für Daten-URIs validieren
> Kryptographisch sichere Zufallswerte für Token verwenden
> Ordnungsgemäße Fehlerbehandlung implementieren
> Auf potentielle DoS-Angriffe überwachen
> Regelmäßige Sicherheitsaudits des Base64-Behandlungscodes

[Base64.sh]