Migliori Pratiche di Sicurezza Base64

// BASE64 NON È CRITTOGRAFIA

Il malinteso di sicurezza più critico è trattare Base64 come crittografia. Base64 è semplicemente codifica - è completamente reversibile senza alcuna chiave o password.

Chiunque può decodificare dati Base64 istantaneamente. Non fare mai affidamento su Base64 per sicurezza o protezione dati.

// ❌ SBAGLIATO: Usare Base64 come 'sicurezza'
const password = 'secret123';
const encoded = btoa(password); // c2VjcmV0MTIz
// Chiunque può decodificare questo istantaneamente!

// ✅ CORRETTO: Hash appropriato della password
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Questo è effettivamente sicuro

// VALIDAZIONE INPUT

Valida sempre l'input Base64 per prevenire attacchi di iniezione e errori dell'applicazione:

Una validazione appropriata previene che input maligni causino problemi di sicurezza o crash dell'applicazione.

// Valida formato Base64
function isValidBase64(str) {
    // Controlla formato: solo caratteri Base64 validi
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Controlla lunghezza (deve essere multiplo di 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Testa decodifica
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Decodifica sicura con validazione
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('L\'input deve essere stringa');
    }
    
    if (input.length > maxLength) {
        throw new Error('Input troppo lungo');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Base64 non valido');
    }
    
    return atob(input);
}

// PREVENZIONE XSS

I dati Base64 possono contenere script maligni quando decodificati. Sanifica sempre l'output quando mostri contenuto decodificato:

Non fidarti mai dell'input Base64 dagli utenti. Sanifica sempre prima di renderizzare in HTML.

// ❌ PERICOLOSO: Iniezione HTML diretta
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // Vulnerabilità XSS!
}

// ✅ SICURO: Sanifica output
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Crea nodo testo (nessuna esecuzione HTML)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // O scappa entità HTML
    const escaped = decoded
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// LIMITI DI DIMENSIONE

La codifica Base64 aumenta la dimensione dei dati di circa il 33%. Implementa limiti di dimensione per prevenire attacchi DoS:

Input Base64 senza restrizioni può consumare memoria eccessiva e potenza di elaborazione.

> Imposta limiti massimi di lunghezza input
> Monitora l'uso della memoria durante l'elaborazione
> Implementa timeout per operazioni lunghe
> Usa streaming per set di dati grandi
> Considera compressione prima della codifica
> Limita la frequenza delle operazioni Base64

// GESTIONE SICURA DEI TOKEN

Quando usi Base64 per token o ID sensibili, segui le migliori pratiche di sicurezza:

Una gestione appropriata dei token previene accesso non autorizzato e attacchi basati su token.

// Creazione token sicuro
function createSecureToken() {
    // Usa valori random crittograficamente sicuri
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Converti in Base64 e rendi sicuro per URL
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Validazione token sicura
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Controlla lunghezza
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Controlla formato Base64 sicuro per URL
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// SICUREZZA DATA URI

I data URI Base64 possono contenere contenuto maligno. Valida e sanifica sempre i data URI:

Data URI maligni possono eseguire script, caricare risorse esterne o contenere contenuto inappropriato.

// Valida 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('Formato data URI non valido');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Valida tipo MIME
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Tipo MIME non supportato: ${mimeType}`);
    }
    
    // Valida dati Base64
    if (!isValidBase64(base64Data)) {
        throw new Error('Base64 non valido nel data URI');
    }
    
    // Controlla dimensione
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // Limite 1MB
        throw new Error('Data URI troppo grande');
    }
    
    return { mimeType, base64Data };
}

// CHECKLIST IMPLEMENTAZIONE SICURA

> Non usare mai Base64 come crittografia o misura di sicurezza
> Valida sempre formato e lunghezza input Base64
> Sanifica output decodificato prima di mostrarlo
> Implementa limiti di dimensione e timeout
> Usa Base64 sicuro per URL per applicazioni web
> Valida tipi MIME per data URI
> Usa valori random crittograficamente sicuri per token
> Implementa gestione errori appropriata
> Monitora potenziali attacchi DoS
> Audit di sicurezza regolari del codice di gestione Base64

[Base64.sh]