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

O MD5 e o SHA-1 continuam a ser muito utilizados em bases de código de produção, apesar de estarem criptograficamente quebrados há décadas. A MD5 é considerada insegura desde 2004 e a SHA-1 desde 2017. No entanto, os programadores continuam a utilizá-los para hashing de palavras-passe, assinaturas digitais e verificação de integridade, onde os ataques de colisão e os ataques de pré-imagem representam verdadeiros riscos de segurança. O custo computacional para gerar colisões MD5 é agora trivial, e os ataques de colisão SHA-1 são práticos com recursos de computação em nuvem.

Porque é importante

Implicações de segurança: O MD5 e o SHA-1 são vulneráveis a ataques de colisão em que duas entradas diferentes produzem o mesmo resultado de hash. Os atacantes exploram este facto para criar ficheiros maliciosos com o mesmo hash que os legítimos, contornando as verificações de integridade. Para o armazenamento de palavras-passe, estes algoritmos são catastroficamente fracos porque são rápidos, tornando triviais os ataques de força bruta e de tabela arco-íris. Uma GPU moderna pode calcular milhares de milhões de hashes MD5 por segundo, o que significa que uma palavra-passe de 8 caracteres pode ser decifrada em horas.

Conformidade e risco legal: Normas de segurança como PCI DSS, HIPAA e SOC 2 proíbem explicitamente MD5 e SHA-1 para fins criptográficos. A sua utilização em ambientes regulamentados cria falhas de auditoria e responsabilidade legal. Os principais navegadores avisam agora os utilizadores quando encontram certificados SHA-1, prejudicando a confiança e bloqueando potencialmente o acesso aos seus serviços.

Manutenção do código: Quando são descobertos algoritmos de hashing desactualizados no código, estes requerem uma correção imediata. Isto cria uma dívida técnica que se agrava com o 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 dispendiosas e correcções de segurança de emergência.

Expansão da superfície de ataque: Os algoritmos de hashing fracos criam múltiplos vectores de ataque. As bases de dados de palavras-passe tornam-se vulneráveis à quebra offline. As assinaturas digitais podem ser forjadas. Os sistemas de integridade de ficheiros podem ser contornados. Cada utilização de MD5 ou SHA-1 é um potencial incidente de segurança à espera de 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;
}

Porque é que não é seguro: O MD5 para hashing de palavras-passe não oferece segurança contra ferramentas de cracking modernas. O SHA-1 para a integridade dos ficheiros pode ser derrotado por ataques de colisão, permitindo que ficheiros maliciosos passem na verificação. Ambos os algoritmos são computacionalmente baratos para a força bruta.

Conformidade:

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;
}

Porque é que é seguro: O PBKDF2 com SHA-256 e uma elevada contagem de iterações (310.000) torna a quebra de palavras-passe exponencialmente mais lenta. O SHA-256 para integridade de ficheiros é resistente a colisões, sem ataques práticos conhecidos. Ambos os algoritmos cumprem as normas de segurança actuais e os requisitos de conformidade.

Conclusão

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