[BEVEILIGING] 7 min lezen

[BEVEILIGING] Base64 Beveiliging Best Practices

Belangrijke beveiligingsoverwegingen bij het werken met Base64 codering in webapplicaties.

Januari 2025 | security

// BASE64 IS GEEN VERSLEUTELING

De meest kritieke beveiligingsmisvatting is Base64 behandelen als versleuteling. Base64 is alleen maar codering - het is volledig omkeerbaar zonder enige sleutel of wachtwoord.

Iedereen kan Base64-data onmiddellijk decoderen. Vertrouw nooit op Base64 voor beveiliging of gegevensbescherming.

// ❌ FOUT: Base64 gebruiken als 'beveiliging'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Iedereen kan dit onmiddellijk decoderen!

// ✅ JUIST: Juiste wachtwoord hashing
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Dit is echt veilig

// INVOERVALIDATIE

Valideer altijd Base64-invoer om injectie-aanvallen en applicatiefouten te voorkomen:

Juiste validatie voorkomt dat kwaadaardige invoer beveiligingsproblemen of applicatiecrashes veroorzaakt.

// Valideer Base64-formaat
function isValidBase64(str) {
    // Controleer formaat: alleen geldige Base64-karakters
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Controleer lengte (moet een veelvoud van 4 zijn)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Test decodering
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Veilige decodering met validatie
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Invoer moet string zijn');
    }
    
    if (input.length > maxLength) {
        throw new Error('Invoer te lang');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Ongeldige Base64');
    }
    
    return atob(input);
}

// XSS PREVENTIE

Base64-data kan kwaadaardige scripts bevatten wanneer gedecodeerd. Zuiver altijd uitvoer bij het weergeven van gedecodeerde inhoud:

Vertrouw nooit Base64-invoer van gebruikers. Zuiver altijd voordat je rendert in HTML.

// ❌ GEVAARLIJK: Directe HTML-injectie
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // XSS-kwetsbaarheid!
}

// ✅ VEILIG: Uitvoer zuiveren
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Tekstnode maken (geen HTML-uitvoering)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // Of HTML-entiteiten escapen
    const escaped = decoded
        .replace(/&/g, '&')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// GROOTTELIMIETEN

Base64-codering vergroot datagrootte met ~33%. Implementeer groottelimieten om DoS-aanvallen te voorkomen:

Onbeperkte Base64-invoer kan overmatig geheugen en verwerkingskracht verbruiken.

  • > Stel maximale invoerlengtelimieten in
  • > Monitor geheugengebruik tijdens verwerking
  • > Implementeer timeouts voor lange bewerkingen
  • > Gebruik streaming voor grote datasets
  • > Overweeg compressie voor codering
  • > Beperk snelheid van Base64-bewerkingen

// VEILIGE TOKEN BEHANDELING

Bij het gebruiken van Base64 voor tokens of gevoelige ID's, volg beveiligings best practices:

Juiste tokenbehandeling voorkomt ongeautoriseerde toegang en token-gebaseerde aanvallen.

// Veilige token creatie
function createSecureToken() {
    // Gebruik cryptografisch veilige willekeurige waarden
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Converteer naar Base64 en maak URL-veilig
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Veilige token validatie
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Controleer lengte
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Controleer URL-veilige Base64-formaat
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATA URI BEVEILIGING

Base64 data URI's kunnen kwaadaardige inhoud bevatten. Valideer en zuiver altijd data URI's:

Kwaadaardige data URI's kunnen scripts uitvoeren, externe bronnen laden of ongepaste inhoud bevatten.

// Valideer data URI
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('Ongeldig data URI-formaat');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Valideer MIME-type
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Niet-ondersteund MIME-type: ${mimeType}`);
    }
    
    // Valideer Base64-data
    if (!isValidBase64(base64Data)) {
        throw new Error('Ongeldige Base64 in data URI');
    }
    
    // Controleer grootte
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // 1MB-limiet
        throw new Error('Data URI te groot');
    }
    
    return { mimeType, base64Data };
}

// VEILIGE IMPLEMENTATIE CHECKLIST

  • > Gebruik nooit Base64 als versleuteling of beveiligingsmaatregel
  • > Valideer altijd Base64-invoerformaat en lengte
  • > Zuiver gedecodeerde uitvoer voordat je weergeeft
  • > Implementeer groottelimieten en timeouts
  • > Gebruik URL-veilige Base64 voor webapplicaties
  • > Valideer MIME-types voor data URI's
  • > Gebruik cryptografisch veilige willekeurige waarden voor tokens
  • > Implementeer juiste foutafhandeling
  • > Monitor voor potentiële DoS-aanvallen
  • > Regelmatige beveiligingsaudits van Base64-behandelingscode