[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.
// 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, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
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