[SEGURIDAD] 7 min de lectura

[SEGURIDAD] Mejores Prácticas de Seguridad Base64

Consideraciones importantes de seguridad al trabajar con codificación Base64 en aplicaciones web.

Enero 2025 | security

// BASE64 NO ES CIFRADO

El concepto erróneo más crítico de seguridad es tratar Base64 como cifrado. Base64 es meramente codificación - es completamente reversible sin ninguna clave o contraseña.

Cualquiera puede decodificar datos Base64 instantáneamente. Nunca confíes en Base64 para seguridad o protección de datos.

// ❌ INCORRECTO: Usar Base64 como 'seguridad'
const password = 'secreto123';
const encoded = btoa(password); // c2VjcmV0bzEyMw==
// ¡Cualquiera puede decodificar esto instantáneamente!

// ✅ CORRECTO: Hash apropiado de contraseña
import bcrypt from 'bcrypt';
const password = 'secreto123';
const hashedPassword = await bcrypt.hash(password, 12);
// Esto es realmente seguro

// VALIDACIÓN DE ENTRADA

Siempre valida la entrada Base64 para prevenir ataques de inyección y errores de aplicación:

La validación apropiada previene que entradas maliciosas causen problemas de seguridad o fallos de aplicación.

// Validar formato Base64
function isValidBase64(str) {
    // Verificar formato: solo caracteres Base64 válidos
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Verificar longitud (debe ser múltiplo de 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Probar decodificación
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Decodificación segura con validación
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('La entrada debe ser una cadena');
    }
    
    if (input.length > maxLength) {
        throw new Error('Entrada demasiado larga');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Base64 inválido');
    }
    
    return atob(input);
}

// PREVENCIÓN XSS

Los datos Base64 pueden contener scripts maliciosos cuando se decodifican. Siempre sanitiza la salida al mostrar contenido decodificado:

Nunca confíes en entrada Base64 de usuarios. Siempre sanitiza antes de renderizar en HTML.

// ❌ PELIGROSO: Inyección HTML directa
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // ¡Vulnerabilidad XSS!
}

// ✅ SEGURO: Sanitizar salida
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Crear nodo de texto (sin ejecución HTML)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // O escapar entidades HTML
    const escaped = decoded
        .replace(/&/g, '&')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// LÍMITES DE TAMAÑO

La codificación Base64 aumenta el tamaño de los datos en aproximadamente 33%. Implementa límites de tamaño para prevenir ataques DoS:

Las entradas Base64 sin restricciones pueden consumir memoria excesiva y poder de procesamiento.

  • > Establecer límites máximos de longitud de entrada
  • > Monitorear uso de memoria durante el procesamiento
  • > Implementar timeouts para operaciones largas
  • > Usar streaming para conjuntos de datos grandes
  • > Considerar compresión antes de codificar
  • > Limitar la tasa de operaciones Base64

// MANEJO SEGURO DE TOKENS

Al usar Base64 para tokens o IDs sensibles, sigue las mejores prácticas de seguridad:

El manejo apropiado de tokens previene acceso no autorizado y ataques basados en tokens.

// Creación de token seguro
function createSecureToken() {
    // Usar valores aleatorios criptográficamente seguros
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Convertir a Base64 y hacer seguro para URLs
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Validación segura de token
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Verificar longitud
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Verificar formato Base64 seguro para URLs
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// SEGURIDAD DE URI DE DATOS

Los URIs de datos Base64 pueden contener contenido malicioso. Siempre valida y sanitiza los URIs de datos:

Los URIs de datos maliciosos pueden ejecutar scripts, cargar recursos externos o contener contenido inapropiado.

// Validar URI de datos
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 de URI de datos inválido');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Validar tipo MIME
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Tipo MIME no soportado: ${mimeType}`);
    }
    
    // Validar datos Base64
    if (!isValidBase64(base64Data)) {
        throw new Error('Base64 inválido en URI de datos');
    }
    
    // Verificar tamaño
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // Límite 1MB
        throw new Error('URI de datos demasiado grande');
    }
    
    return { mimeType, base64Data };
}

// CHECKLIST DE IMPLEMENTACIÓN SEGURA

  • > Nunca usar Base64 como medida de cifrado o seguridad
  • > Siempre validar formato y longitud de entrada Base64
  • > Sanitizar salida decodificada antes de mostrar
  • > Implementar límites de tamaño y timeouts
  • > Usar Base64 seguro para URLs en aplicaciones web
  • > Validar tipos MIME para URIs de datos
  • > Usar valores aleatorios criptográficamente seguros para tokens
  • > Implementar manejo apropiado de errores
  • > Monitorear ataques DoS potenciales
  • > Auditorías regulares de seguridad del código de manejo Base64