Base64 Säkerhet Bästa Praxis

// BASE64 ÄR INTE KRYPTERING

Den mest kritiska säkerhetsmissuppfattningen är att behandla Base64 som kryptering. Base64 är bara kodning - det är helt reversibelt utan någon nyckel eller lösenord.

Vem som helst kan avkoda Base64-data omedelbart. Förlita dig aldrig på Base64 för säkerhet eller dataskydd.

// ❌ FEL: Använda Base64 som 'säkerhet'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Vem som helst kan avkoda detta omedelbart!

// ✅ RÄTT: Korrekt lösenordshashning
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Detta är faktiskt säkert

// INDATAVALIDERING

Validera alltid Base64-indata för att förhindra injektionsattacker och applikationsfel:

Korrekt validering förhindrar att skadlig indata orsakar säkerhetsproblem eller applikationskrascher.

// Validera Base64-format
function isValidBase64(str) {
    // Formatcheck: endast giltiga Base64-tecken
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Längdcheck (måste vara en multipel av 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Testpå avkodning
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Säker avkodning med validering
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Indata måste vara sträng');
    }
    
    if (input.length > maxLength) {
        throw new Error('Indata för lång');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Ogiltig Base64');
    }
    
    return atob(input);
}

// XSS-FÖREBYGGANDE

Base64-data kan innehålla skadliga skript när de avkodas. Sanera alltid utdata när avkodad innehåll visas:

Lita aldrig på Base64-indata från användare. Sanera alltid innan rendering i HTML.

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

// ✅ SÄKERT: Sanera utdata
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Skapa textnod (ingen HTML-exekvering)
    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;
}

// STORLEKSGRÄNSER

Base64-kodning ökar datastorleken med ~33%. Implementera storleksgränser för att förhindra DoS-attacker:

Obegränsad Base64-indata kan konsumera överdriven minne och processorkraft.

> Sätt maximala indatalängdgränser
> Övervaka minnesanvändning under bearbetning
> Implementera timeouts för långa operationer
> Använd streaming för stora dataset
> Överväg komprimering före kodning
> Ratebegränsa Base64-operationer

// SÄKER TOKENHANTERING

När du använder Base64 för tokens eller känsliga ID:n, följ säkerhetsbästa praxis:

Korrekt tokenhantering förhindrar obehörig åtkomst och tokenbaserade attacker.

// Säker tokenskapande
function createSecureToken() {
    // Använd kryptografiskt säkra slumpvärden
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Konvertera till Base64 och gör URL-säker
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Säker tokenvalidering
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Kontrollera längd
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Kontrollera URL-säkert Base64-format
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATA-URI SÄKERHET

Base64 data-URI:er kan innehålla skadligt innehåll. Validera och sanera alltid data-URI:er:

Skadliga data-URI:er kan exekvera skript, ladda externa resurser eller innehålla olämpligt innehåll.

// Validera 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('Ogiltigt data-URI-format');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Validera MIME-typ
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Stöds inte MIME-typ: ${mimeType}`);
    }
    
    // Validera Base64-data
    if (!isValidBase64(base64Data)) {
        throw new Error('Ogiltig Base64 i data-URI');
    }
    
    // Kontrollera storlek
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // 1MB-gräns
        throw new Error('Data-URI för stor');
    }
    
    return { mimeType, base64Data };
}

// SÄKER IMPLEMENTERINGS CHECKLISTA

> Använd aldrig Base64 som kryptering eller säkerhetsåtgärd
> Validera alltid Base64-indataformat och längd
> Sanera avkodad utdata innan visning
> Implementera storleksgränser och timeouts
> Använd URL-säker Base64 för webbapplikationer
> Validera MIME-typer för data-URI:er
> Använd kryptografiskt säkra slumpvärden för tokens
> Implementera korrekt felhantering
> Övervaka för potentiella DoS-attacker
> Regelbundna säkerhetsreviews av Base64-hanteringskod

[Base64.sh]