Entropia de Shanon no dia a dia do Dev

Em 1948, Claude Shannon publicou um artigo chamado “A Mathematical Theory of Communication” que fundou a Teoria da Informacao. Dentre varias coisas, ele definiu uma formula que mede a incerteza de uma fonte de dados. Essa formula ficou conhecida como Entropia de Shannon, e embora tenha nascido no contexto de telecomunicacoes, ela aparece em mais places do que voce imagina no dia a dia de quem trabalha com tecnologia.

A formula e esta:

$$ H(X) = -\sum p(x) \log_2 p(x) $$

Onde:

• p(x) e a probabilidade de cada simbolo aparecer na fonte.
• O resultado e medido em bits.

Quanto mais imprevisivel a fonte, maior a entropia. Quanto mais repetitiva, menor.

Vamos percorrer situacoes reais onde esse conceito aparece, sem precisar de um PhD em matematica para entender.

O que a entropia realmente mede

Antes de sair aplicando, vale entender o que a formula esta dizendo em termos simples.

Se voce tem uma moeda justa, com 50% de chance para cada lado, a entropia e 1 bit. Voce nao consegue prever o resultado. Ja uma moeda viciada que sempre cai em “cara” tem entropia 0 bits, porque nao ha nenhuma incerteza.

Em Python, uma implementacao basica ficaria assim:

from collections import Counter
from math import log2

def shannon(values):
    total = len(values)
    counts = Counter(values)

    return -sum(
        (n / total) * log2(n / total)
        for n in counts.values()
    )

Onde:

• values: e uma lista com os valores que voce quer analisar
• counts: conta quantas vezes cada valor aparece
• log2: e usado porque estamos medindo em bits

Isso e tudo que voce precisa para comecar. O resto sao aplicacoes.

Compressao de dados

Foi o problema original que Shannon resolveu. Se uma fonte tem muitos caracteres repetidos, a entropia e baixa e da para comprimir bem.

Exemplo:

AAAAAAAAAAAAAA

Entropia proxima de 0 bits. Nao ha surpresa nenhuna.

Ja:

ABCDABCDABCD

Tem entropia maior. E:

XJ4#9aK!zPq

Possui entropia ainda maior, proxima do maximo para 11 simbolos distintos.

Algoritmos como Huffman, Arithmetic Coding, Brotli e Zstd usam conceitos derivados da entropia de Shannon. O Huffman, por exemplo, constroi uma arvore onde os simbolos mais frequentes recebem codigos menores. Isso e exatamente o que a entropia prediz: se voce sabe que um simbolo aparece muito, pode representa-lo com menos bits.

Senhas e entropia

Pode-se medir a entropia de uma senha para estimar sua forca.

from collections import Counter
from math import log2

def entropy(text):
    total = len(text)
    freq = Counter(text)

    return -sum(
        (c / total) * log2(c / total)
        for c in freq.values()
    )

print(entropy("aaaaaaaa"))        # ~0 bits
print(entropy("a8K$2pL@"))        # alta entropia

Uma senha como aaaaaaaa tem entropia proxima de zero, porque todos os caracteres sao iguais. Ja a8K$2pL@ distribui os simbolos de forma muito mais uniforme.

Uso pratico:

• Validadores de senha que calculam entropia em vez de so exigir maiuscula+numero+caractere especial
• IAM corporativo que rejeita senhas previsiveis
• Politicas de autenticacao baseadas na forca real, nao em regras.genericas

Detectando dados criptografados

Arquivos criptografados possuem uma distribuicao quase uniforme dos bytes. Isso significa que a entropia por byte fica proxima de 8.

import math

def byte_entropy(data):
    freq = [0] * 256

    for b in data:
        freq[b] += 1

    total = len(data)

    return -sum(
        (f / total) * math.log2(f / total)
        for f in freq if f
    )

Se a entropia estiver proxima de 8 bits por byte, o conteudo provavelmente esta:

• Comprimido
• Criptografado

Uso real:

• Antivirus que calculam entropia para detectar payloads ofuscados
• Analise forense para identificar regioes de disco com conteudo cifrado
• Malware detection em sandbox, ja que malware empacotado apresenta entropia anomala

Descobrindo segredos em repositorios Git

Ferramentas de seguranca calculam entropia para detectar strings como:

AKIAIOSFODNN7EXAMPLE

ou:

sk_live_4eC39HqLyjWDarjtT1zdp7dc

Essas strings possuem entropia alta porque sao aleatorias por design. Ferramentas como GitLeaks e TruffleHog usam essa tecnica: elas escaneiam diffs do Git e calculam a entropia de cada string. Se a entropia ultrapassa um limiar, a string e sinalizada como possivel segredo.

Isso e particularmente util em pipelines de CI/CD, onde ninguem quer que uma chave AWS va para o main sem ser detectada.

Machine Learning e arvores de decisao

Na construcao de arvores de decisao, algoritmos como ID3, C4.5 e Random Forest calculam algo chamado Information Gain, que e baseado diretamente na entropia de Shannon.

A ideia e: para cada feature disponivel, calcula-se o quanto ela reduz a incerteza sobre a classe alvo. A feature que mais reduz a entropia e escolhida como o no de decisao.

Exemplo: se voce esta tentando classificar emails como spam ou nao, e a feature “contem a palavra gratis” reduz significativamente a entropia da classificacao, ela sera escolhida como um no da arvore.

Balanceamento de datasets

Imagine um dataset com:

95% gato
 5% cachorro

A entropia e baixa. O modelo pode simplesmente chutar “gato” toda vez e acertar 95%.

Ja:

50% gato
50% cachorro

A entropia e maxima. O modelo precisa realmente aprender para distinguir.

Isso serve para:

• Avaliar datasets antes de treinar modelos
• Detectar desbalanceamento que levaria a modelos enviesados
• Decidir se e necesario oversampling, undersampling ou SMOTE

Monitoramento e observabilidade

Como trabalho com observabilidade, este e o uso que mais me interessa no dia a dia.

Pode-se calcular a entropia de:

• URLs acessadas
• User-Agents recebidos
• IPs de origem
• Headers HTTP

Exemplo de trafego normal para um servico de login:

/login
/login
/login
/login

Entropia baixa. Todo mundo esta indo pro mesmo lugar.

Agora um ataque automatizado:

/login
/api/1
/api/2
/api/3
/random

Entropia alta. O atacante esta varrendo rotas diferentes.

Aplicacoes praticas:

• Deteccao de scanners e bots
• Identificacao de ataques automatizados em WAF
• Alertas baseados em mudanca abrupta de entropia no trafego

Deteccao de DNS Tunneling

Ataques de exfiltracao costumam gerar subdominios aleatorios para tunelar dados pelo DNS:

a8dj39dj3j.example.com
k39fj29d2j.example.com
9fjf93jf93.example.com

A entropia dos labels DNS fica anormalmente alta comparada ao padrao normal de queries. Um subdominio legitimo como www ou mail tem entropia muito menor que a8dj39dj3j.

Muito usado em:

• SOC para correlacionar alertas de DNS anomalo
• SIEM como regra de correlacao
• IDS para sinalizar possivel exfiltracao

Analise de logs e cardinalidade

Voce pode detectar comportamentos anormais observationando a cardinalidade dos campos dos seus logs.

Exemplo de log normal:

{
  "service": "checkout"
}

Exemplo de log anomalo:

{
  "service": "x9fj3k29dj29d"
}

Uma explosao de cardinalidade em um campo geralmente aumenta a entropia. Em vez de 5 servicos distintos, voce passa a ver 5000 valores unicos em uma janela de tempo curta.

Isso e util para:

• OpenTelemetry para detectar spans anomales
• Prometheus para criar metricas de cardinalidade
• Datadog e Grafana para alertar sobre metrics com cardinalidade fora do padrao

Na pratica, se voce tem um metric com label service que explode de 10 valores para 10000 em uma hora, sua entropia vai disparar junto.

Geracao de numeros aleatorios

Pode-se usar entropia para avaliar a qualidade de um RNG.

import os

data = os.urandom(100000)

A entropia dos dados gerados por os.urandom deve se aproximar do maximo, porque ele usa fontes de entropia do kernel. Ja um RNG fraco como random.random do Python (que usa Mersenne Twister) pode apresentar padroes detectaveis.

Uso em:

• Criptografia, onde a aleatoriedade e requisito de seguranca
• Geracao de tokens de sessao
• UUIDs que precisam ser imprevisiveis
• Sorteios e loterias

Deteccao de fraude

Em sistemas financeiros, a mudanca brusca de entropia pode indicar fraude.

Campos monitorados:

• Numero de transacoes por periodo
• Paises de origem
• Dispositivos utilizados
• Horarios de acesso

Exemplo: um usuario que normalmente acessa apenas de Sao Paulo e subitamente apresenta acessos de:

Sao Paulo
Alemanha
India
Canada
Russia

A entropia geografica aumenta de forma abrupta, o que e um forte indicador de conta comprometida ou fraude.

Engenharia de trafego e APIs

Para quem trabalha com Nginx e APIs, calcular a entropia de campos como User-Agent, Referer, IP e Path revela padroes distintos entre humanos e bots.

Trafego humano tipico:

/
/produto/1
/carrinho
/checkout

Trafego de bot:

/1
/2
/3
/4
/5
/6

A distribuicao das rotas apresenta entropia distinta. Humanos navegam com proposito; bots varrem de forma sequencial ou aleatoria.

Colocando em pratica: detector simples de anomalia

Para quem trabalha com observabilidade, um detector de ataque baseado em entropia pode ser implementado em poucas linhas:

from collections import Counter
from math import log2

def shannon(values):
    total = len(values)
    counts = Counter(values)

    return -sum(
        (n / total) * log2(n / total)
        for n in counts.values()
    )

Se a entropia das URLs, User-Agents ou IPs subir de forma abrupta em uma janela de tempo, voce pode:

• Gerar um alerta no Prometheus com uma metrica customizada
• Criar um atributo no OpenTelemetry sinalizando periodo suspeito
• Acionar um bloqueio automatico no Nginx ou Cloudflare
• Disparar uma automacao no SIEM

E uma tecnica relativamente simples e muito eficiente para identificar mudancas de comportamento sem precisar de modelos complexos de machine learning. Em ambientes de observabilidade, combinar entropia com metricas de cardinalidade e uma abordagem leve que escala bem e gera alertas acionaveis.

Referencias

• A Mathematical Theory of Communication - Claude Shannon (1948)
• GitLeaks
• TruffleHog
• Huffman Coding
• OpenTelemetry