[SIKKERHET] 7 min lesing

[SIKKERHET] Base64 Sikkerhet Beste Praksis

Viktige sikkerhetshensyn når du arbeider med Base64-koding i webapplikasjoner.

Januar 2025 | security

// BASE64 ER IKKE KRYPTERING

Den mest kritiske sikkerhetsmisforståelsen er å behandle Base64 som kryptering. Base64 er bare koding - det er fullstendig reversibelt uten nøkkel eller passord.

Hvem som helst kan øyeblikkelig dekode Base64-data. Stol aldri på Base64 for sikkerhet eller databeskyttelse.

// ❌ FEIL: Bruke Base64 som 'sikkerhet'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Hvem som helst kan dekode dette øyeblikkelig!

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

// INPUT VALIDERING

Valider alltid Base64-input for å forhindre injeksjonsangrep og applikasjonsfeil:

Riktig validering forhindrer ondsinnet input fra å forårsake sikkerhetsproblemer eller applikasjonskrasj.

// Valider Base64-format
function isValidBase64(str) {
    // Formatsjekk: kun gyldige Base64-tegn
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Lengdesjekk (må være multiplum av 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Test dekoding
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Sikker dekoding med validering
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Input må 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 FOREBYGGING

Base64-data kan inneholde ondsinnet skript når dekoded. Rens alltid output når dekoded innhold vises:

Stol aldri på Base64-input fra brukere. Rens alltid før rendering i HTML.

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

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

// STØRRELSESGRENSER

Base64-koding øker datastørrelsen med ~33%. Implementer størrelsesgrenser for å forhindre DoS-angrep:

Ubegrenset Base64-input kan konsumere overdreven minne og prosessorkraft.

  • > Sett maksimale inputlengdegrenser
  • > Overvåk minnebruk under behandling
  • > Implementer timeouts for lange operasjoner
  • > Bruk streaming for store datasett
  • > Vurder komprimering før koding
  • > Ratebegrens Base64-operasjoner

// SIKKER TOKEN-HÅNDTERING

Når du bruker Base64 for tokens eller sensitive ID-er, følg sikkerhetens beste praksis:

Riktig token-håndtering forhindrer uautorisert tilgang og token-baserte angrep.

// Sikker token-opprettelse
function createSecureToken() {
    // Bruk kryptografisk sikre tilfeldige verdier
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Konverter til Base64 og gjø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;
    }
    
    // Sjekk lengde
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Sjekk URL-sikkert Base64-format
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATA URI SIKKERHET

Base64 data URI-er kan inneholde ondsinnede innhold. Valider og rens alltid data URI-er:

Ondsinnet data URI-er kan utføre skript, laste eksterne ressurser eller inneholde upassende innhold.

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

// SIKKER IMPLEMENTERING SJEKKLISTE

  • > Bruk aldri Base64 som kryptering eller sikkerhetsgrep
  • > Valider alltid Base64 input-format og lengde
  • > Rens dekoded output før visning
  • > Implementer størrelsesgrenser og timeouts
  • > Bruk URL-sikker Base64 for webapplikasjoner
  • > Valider MIME-typer for data URI-er
  • > Bruk kryptografisk sikre tilfeldige verdier for tokens
  • > Implementer riktig feilhåndtering
  • > Overvåk for potensielle DoS-angrep
  • > Regelmessige sikkerhetsgjennomganger av Base64-håndteringskode