Regra
Não utilizar desatualizado hashing ultrapassados a menos que contextualmente 
justificado. utilizar desatualizados hashing desactualizados (MD5, SHA-1)
em qualquer sensíveis à segurança sensíveis à segurança. Estes são criptograficamente
quebrados, fáceis de força bruta, e prejudicar sistema manutenção do sistema.

Idiomas suportados: 45+

Introdução

MD5 e SHA-1 permanecem amplamente utilizados em bases de código em produção, apesar de estarem criptograficamente comprometidos há décadas. MD5 é considerado inseguro desde 2004, SHA-1 desde 2017. No entanto, desenvolvedores continuam a usá-los para hashing de senhas, assinaturas digitais e verificação de integridade, onde ataques de colisão e ataques de pré-imagem representam riscos reais de segurança. O custo computacional para gerar colisões MD5 é agora trivial, e ataques de colisão SHA-1 são práticos com recursos de computação em Cloud.

Por que isso importa

Implicações de segurança: MD5 e SHA-1 são vulneráveis a ataques de colisão, onde duas entradas diferentes produzem o mesmo hash de saída. Atacantes exploram isso para criar arquivos maliciosos com o mesmo hash de arquivos legítimos, ignorando verificações de integridade. Para armazenamento de senhas, esses algoritmos são catastroficamente fracos porque são rápidos, tornando ataques de força bruta e de tabela arco-íris triviais. Uma GPU moderna pode computar bilhões de hashes MD5 por segundo, o que significa que uma senha de 8 caracteres pode ser quebrada em horas.

Risco de conformidade e legal: Padrões de segurança como PCI DSS, HIPAA e SOC 2 proíbem explicitamente MD5 e SHA-1 para fins criptográficos. Usá-los em ambientes regulamentados gera falhas de auditoria e responsabilidade legal. Os principais navegadores agora alertam os usuários ao encontrar certificados SHA-1, prejudicando a confiança e potencialmente bloqueando o acesso aos seus serviços.

Manutenibilidade do código: Quando algoritmos de hash desatualizados são descobertos no código, eles exigem remediação imediata. Isso cria dívida técnica que se acumula ao longo do tempo porque a migração se torna mais difícil à medida que mais dados se acumulam. A adoção precoce de algoritmos seguros evita migrações futuras caras e patches de segurança de emergência.

Expansão da superfície de ataque: Algoritmos de hashing fracos criam múltiplos vetores de ataque. Bancos de dados de senhas tornam-se vulneráveis a cracking offline. Assinaturas digitais podem ser forjadas. Sistemas de integridade de arquivos podem ser contornados. Cada uso de MD5 ou SHA-1 é um incidente de segurança potencial esperando para acontecer.

Exemplos de código

❌ Não-conforme:

const crypto = require('crypto');

function hashPassword(password) {
  return crypto.createHash('md5')
    .update(password)
    .digest('hex');
}

function verifyFileIntegrity(fileContent, expectedHash) {
  const hash = crypto.createHash('sha1')
    .update(fileContent)
    .digest('hex');
  return hash === expectedHash;
}

Por que é inseguro: MD5 para hash de senhas não oferece segurança contra ferramentas de quebra modernas. SHA-1 para integridade de arquivos pode ser superado com ataques de colisão, permitindo que arquivos maliciosos passem pela verificação. Ambos os algoritmos são computacionalmente baratos para ataques de força bruta.

✅ Compatível:

const crypto = require('crypto');

async function hashPassword(password) {
  const salt = crypto.randomBytes(16);
  return new Promise((resolve, reject) => {
    crypto.pbkdf2(password, salt, 310000, 32, 'sha256', (err, key) => {
      if (err) reject(err);
      resolve({ salt: salt.toString('hex'), hash: key.toString('hex') });
    });
  });
}

function verifyFileIntegrity(fileContent, expectedHash) {
  const hash = crypto.createHash('sha256')
    .update(fileContent)
    .digest('hex');
  return hash === expectedHash;
}

Por que é seguro: PBKDF2 com SHA-256 e alta contagem de iterações (310.000) torna a quebra de senhas exponencialmente mais lenta. SHA-256 para integridade de arquivos é resistente a colisões, sem ataques práticos conhecidos. Ambos os algoritmos atendem aos padrões de segurança e requisitos de conformidade atuais.

Conclusão

MD5 e SHA-1 não têm lugar em código sensível à segurança. Suas vulnerabilidades são bem documentadas, exploits estão publicamente disponíveis e alternativas seguras existem em todas as principais linguagens. O caminho de migração é claro: use bcrypt, scrypt ou Argon2 para senhas, e SHA-256 ou SHA-3 para verificação de integridade. Cada dia que esses algoritmos fracos permanecem em produção aumenta sua superfície de ataque.