Base64 Sikkerhed Bedste Praksis

// BASE64 ER IKKE KRYPTERING

Den mest kritiske sikkerhedsmisforståelse er at behandle Base64 som kryptering. Base64 er kun kodning - det er fuldstændigt reversibelt uden nøgle eller adgangskode.

Enhver kan øjeblikkeligt afkode Base64-data. Stol aldrig på Base64 for sikkerhed eller databeskyttelse.

// ❌ FORKERT: Brug af Base64 som 'sikkerhed'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Enhver kan afkode dette øjeblikkeligt!

// ✅ KORREKT: Ordentlig adgangskode-hashing
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Dette er faktisk sikkert

// INPUT VALIDERING

Valider altid Base64-input for at forhindre injektionsangreb og applikationsfejl:

Ordentlig validering forhindrer ondsindet input i at forårsage sikkerhedsproblemer eller applikationsnedbrud.

// Valider Base64-format
function isValidBase64(str) {
    // Format tjek: kun gyldige Base64-tegn
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Længde tjek (skal være multipel af 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Test afkodning
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Sikker afkodning med validering
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Input skal være streng');
    }
    
    if (input.length > maxLength) {
        throw new Error('Input for lang');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Ugyldig Base64');
    }
    
    return atob(input);
}

// XSS FOREBYGGELSE

Base64-data kan indeholde ondsindede scripts, når de afkodes. Rens altid output, når afkodet indhold vises:

Stol aldrig på Base64-input fra brugere. Rens altid før rendering i HTML.

// ❌ FARLIGT: Direkte HTML-injektion
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // XSS-sårbarhed!
}

// ✅ SIKKERT: Rens output
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Opret tekstnode (ingen HTML-udførelse)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // Eller escape HTML-entiteter
    const escaped = decoded
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// STØRRELSE BEGRÆNSNINGER

Base64-kodning øger datastørrelsen med ~33%. Implementer størrelsesbegrænsninger for at forhindre DoS-angreb:

Ubegrænset Base64-input kan forbruge overdreven hukommelse og processorkraft.

> Indstil maksimale inputlængdegrænser
> Overvåg hukommelsesforbrug under behandling
> Implementer timeouts for lange operationer
> Brug streaming til store datasæt
> Overvej komprimering før kodning
> Ratebegræns Base64-operationer

// SIKKER TOKEN HÅNDTERING

Når du bruger Base64 til tokens eller følsomme ID'er, følg sikkerhedens bedste praksis:

Ordentlig token-håndtering forhindrer uautoriseret adgang og token-baserede angreb.

// Sikker token-oprettelse
function createSecureToken() {
    // Brug kryptografisk sikre tilfældige værdier
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Konverter til Base64 og gør URL-sikker
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Sikker token-validering
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Tjek længde
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Tjek URL-sikkert Base64-format
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATA URI SIKKERHED

Base64 data URI'er kan indeholde ondsindede indhold. Valider og rens altid data URI'er:

Ondsindede data URI'er kan udføre scripts, indlæse eksterne ressourcer eller indeholde upassende indhold.

// Valider 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('Ugyldigt data URI-format');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Valider MIME-type
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Ikke-understøttet MIME-type: ${mimeType}`);
    }
    
    // Valider Base64-data
    if (!isValidBase64(base64Data)) {
        throw new Error('Ugyldig Base64 i data URI');
    }
    
    // Tjek størrelse
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // 1MB grænse
        throw new Error('Data URI for stor');
    }
    
    return { mimeType, base64Data };
}

// SIKKER IMPLEMENTERING TJEKLISTE

> Brug aldrig Base64 som kryptering eller sikkerhedsforanstaltning
> Valider altid Base64 input-format og længde
> Rens afkodet output før visning
> Implementer størrelsesbegrænsninger og timeouts
> Brug URL-sikker Base64 til webapplikationer
> Valider MIME-typer for data URI'er
> Brug kryptografisk sikre tilfældige værdier til tokens
> Implementer ordentlig fejlhåndtering
> Overvåg for potentielle DoS-angreb
> Regelmæssige sikkerhedsreviews af Base64-håndteringskode

[Base64.sh]