[SEGURANÇA] 7 min de leitura

[SEGURANÇA] Melhores Práticas de Segurança Base64

Considerações importantes de segurança ao trabalhar com codificação Base64 em aplicações web.

Janeiro 2025 | security

// BASE64 NÃO É CRIPTOGRAFIA

O equívoco de segurança mais crítico é tratar Base64 como criptografia. Base64 é meramente codificação - é completamente reversível sem qualquer chave ou senha.

Qualquer pessoa pode decodificar dados Base64 instantaneamente. Nunca confie em Base64 para segurança ou proteção de dados.

// ❌ ERRADO: Usar Base64 como 'segurança'
const password = 'secreto123';
const encoded = btoa(password); // c2VjcmV0bzEyMw==
// Qualquer pessoa pode decodificar isso instantaneamente!

// ✅ CORRETO: Hash adequado de senha
import bcrypt from 'bcrypt';
const password = 'secreto123';
const hashedPassword = await bcrypt.hash(password, 12);
// Isso é realmente seguro

// VALIDAÇÃO DE ENTRADA

Sempre valide entrada Base64 para prevenir ataques de injeção e erros de aplicação:

Validação adequada previne que entrada maliciosa cause problemas de segurança ou crashes de aplicação.

// Validar formato Base64
function isValidBase64(str) {
    // Verificar formato: apenas caracteres Base64 válidos
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Verificar comprimento (deve ser múltiplo de 4)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Testar decodificação
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Decodificação segura com validação
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Entrada deve ser uma string');
    }
    
    if (input.length > maxLength) {
        throw new Error('Entrada muito longa');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Base64 inválido');
    }
    
    return atob(input);
}

// PREVENÇÃO XSS

Dados Base64 podem conter scripts maliciosos quando decodificados. Sempre sanitize a saída ao exibir conteúdo decodificado:

Nunca confie em entrada Base64 de usuários. Sempre sanitize antes de renderizar em HTML.

// ❌ PERIGOSO: Injeção HTML direta
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // Vulnerabilidade XSS!
}

// ✅ SEGURO: Sanitizar saída
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Criar nó de texto (sem execução HTML)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // Ou escapar entidades HTML
    const escaped = decoded
        .replace(/&/g, '&')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// LIMITES DE TAMANHO

Codificação Base64 aumenta o tamanho dos dados em aproximadamente 33%. Implemente limites de tamanho para prevenir ataques DoS:

Entrada Base64 irrestrita pode consumir memória excessiva e poder de processamento.

  • > Definir limites máximos de comprimento de entrada
  • > Monitorar uso de memória durante processamento
  • > Implementar timeouts para operações longas
  • > Usar streaming para grandes conjuntos de dados
  • > Considerar compressão antes de codificar
  • > Limitar taxa de operações Base64

// TRATAMENTO SEGURO DE TOKENS

Ao usar Base64 para tokens ou IDs sensíveis, siga melhores práticas de segurança:

Tratamento adequado de tokens previne acesso não autorizado e ataques baseados em tokens.

// Criação de token seguro
function createSecureToken() {
    // Usar valores aleatórios criptograficamente seguros
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Converter para Base64 e tornar seguro para URL
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Validação segura de token
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Verificar comprimento
    if (token.length !== expectedLength) {
        return false;
    }
    
    // Verificar formato Base64 seguro para URL
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// SEGURANÇA DE URI DE DADOS

URIs de dados Base64 podem conter conteúdo malicioso. Sempre valide e sanitize URIs de dados:

URIs de dados maliciosos podem executar scripts, carregar recursos externos ou conter conteúdo inadequado.

// Validar URI de dados
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 dados inválido');
    }
    
    const [, mimeType, base64Data] = match;
    
    // Validar tipo MIME
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Tipo MIME não suportado: ${mimeType}`);
    }
    
    // Validar dados Base64
    if (!isValidBase64(base64Data)) {
        throw new Error('Base64 inválido em URI de dados');
    }
    
    // Verificar tamanho
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // Limite 1MB
        throw new Error('URI de dados muito grande');
    }
    
    return { mimeType, base64Data };
}

// CHECKLIST DE IMPLEMENTAÇÃO SEGURA

  • > Nunca usar Base64 como medida de criptografia ou segurança
  • > Sempre validar formato e comprimento de entrada Base64
  • > Sanitizar saída decodificada antes de exibir
  • > Implementar limites de tamanho e timeouts
  • > Usar Base64 seguro para URL em aplicações web
  • > Validar tipos MIME para URIs de dados
  • > Usar valores aleatórios criptograficamente seguros para tokens
  • > Implementar tratamento de erro adequado
  • > Monitorar ataques DoS potenciais
  • > Auditorias regulares de segurança do código de tratamento Base64