Quando li que uma IA decifrou uma mensagem da Enigma parada havia 20 anos, minha primeira reação não foi admiração — foi curiosidade técnica. Como, exatamente, um modelo de linguagem chegou lá onde criptanalistas humanos patinaram por duas décadas? A reportagem do Olhardigital.com.br conta que o GPT-6 Astra e o Claude Opus 5 foram usados pelo desenvolvedor Carter Leffen, e o resultado foi validado por Frode Weierud, referência mundial em Enigma. Esse caso é uma janela rara para o que IA “agêntica” realmente faz — e o que ainda não faz.
Por que esse caso importa para quem desenvolve
Não é só história militar. Quando um LLM consegue montar um simulador de Enigma, vasculhar bases públicas e validar hipóteses contra um corpus histórico, ele está fazendo o que chamamos de agente autônomo com ferramentas. Isso muda como a gente pensa em automação de pesquisa, refatoração de código legado e até auditoria de segurança. Na minha experiência, o ponto que mais chama atenção não é a IA “adivinhar” a chave — é a cadeia de raciocínio que ela constrói para chegar lá.
Para um dev sênior, o caso levanta três questões práticas:
- Como usar LLMs como ferramentas de pesquisa que cruzam fontes heterogêneas?
- Quando confiar no resultado de uma IA em um domínio onde você não é especialista (como criptoanálise histórica)?
- O que significa “validação” quando o modelo encontra material fora do seu corpus de treinamento?
Entendendo a Enigma: por que isso era difícil
A máquina Enigma usava rotores eletromecânicos com posições iniciais, anéis e plugboard. Combinando tudo, o espaço de chaves passava da casa dos 10²³ configurações possíveis. O Bombe de Turing, construído em Bletchley Park, reduzia esse espaço eliminando combinações que violavam padrões linguísticos conhecidos (“cribs”). Mesmo assim, mensagens curtas, sem cribs ou com configurações desconhecidas permaneceram sem solução por décadas.
Hoje restam cerca de sete mensagens sem solução, segundo Weierud. São exatamente os casos onde o Bombe tradicional tropeça: pouca redundância estatística, configurações exóticas ou texto cifrado muito curto. É aí que entra a IA.
O método: o que a IA fez de diferente
O detalhe que me chamou atenção na reportagem é que o Astra não tentou “adivinhar” a chave. O desenvolvedor pediu para o modelo procurar uma mensagem não decifrada, examinar pistas históricas e construir um simulador da máquina. Esse é o pulo do gato: em vez de tratar criptoanálise como problema de força bruta, o modelo a tratou como problema de pesquisa + simulação + iteração.
Em termos práticos, o fluxo foi:
- Buscar uma mensagem alvo no banco público do Crypto Cellar.
- Recolher metadados: data, origem presumida, tipo de rede de comunicação (Kriegsmarine? Luftwaffe?).
- Reconstruir a configuração provável da máquina naquele contexto histórico.
- Rodar simulações contra candidatos até obter texto plausível em alemão ou em código conhecido.
- Submeter o resultado a um especialista humano para validação.
Esse pipeline é essencialmente o que um engenheiro de software faria manualmente — só que acelerado e com consulta cruzada de fontes que um humano levaria meses para percorrer.
Na Prática: simulando uma Enigma em Python
Para entender o que a IA fez, vale ver como se monta um simulador de Enigma. Não vou implementar a máquina completa (são centenas de linhas), mas o esqueleto abaixo mostra a lógica dos rotores — peça central do problema que a IA teve que reconstruir:
# Esqueleto simplificado de um rotor da Enigma
ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
class Rotor:
def __init__(self, wiring, notch, position=0, ring=0):
self.wiring = wiring # fiação interna do rotor
self.notch = notch # ponto de virada
self.position = position # posição inicial
self.ring = ring # anel de ajuste
def forward(self, c):
shift = self.position - self.ring
idx = (ALPHABET.index(c) + shift) % 26
out = self.wiring[idx]
return ALPHABET[(ALPHABET.index(out) - shift) % 26]
def backward(self, c):
shift = self.position - self.ring
idx = (ALPHABET.index(c) + shift) % 26
out = ALPHABET.index(self.wiring.index(idx))
return ALPHABET[(out - shift) % 26]
def step(self):
# Lógica de turnover: rotor avança e, em certas posições,
# também empurra o próximo rotor (o famoso "double stepping")
self.position = (self.position + 1) % 26
return self.position == self.notch
class Enigma:
def __init__(self, rotors, reflector, plugboard=""):
self.rotors = rotors
self.reflector = reflector
self.plugboard = self._build_plugboard(plugboard)
def _build_plugboard(self, pairs):
mapping = {c: c for c in ALPHABET}
for pair in pairs.upper().split():
a, b = pair[0], pair[1]
mapping[a], mapping[b] = b, a
return mapping
def encrypt(self, text):
out = []
for ch in text.upper():
if ch not in ALPHABET:
continue
# Avança rotores antes de cifrar (pré-step)
if self.rotors[2].step():
if self.rotors[1].step():
self.rotors[0].step()
ch = self.plugboard[ch]
for rotor in reversed(self.rotors):
ch = rotor.forward(ch)
ch = self.reflector[ch]
for rotor in self.rotors:
ch = rotor.backward(ch)
out.append(self.plugboard[ch])
return "".join(out)
# Exemplo de uso (valores ilustrativos — rotores reais são outros)
R1 = "EKMFLGDQVZNTOWYHXUSPAIBRCJ"
R2 = "AJDKSIRUXBLHWTMCQGZNPYFVOE"
R3 = "BDFHJLCPRTXVZNYEIWGAKMUSQO"
REF = "YRUHQSLDPXNGOKMIEBFZCWVJAT"
enigma = Enigma(
rotors=[
Rotor(R1, notch="Q", position=0),
Rotor(R2, notch="E", position=0),
Rotor(R3, notch="V", position=0),
],
reflector=REF,
plugboard="AB CD EF"
)
print(enigma.encrypt("HELLO"))Esse código é didático, não operacional. Reparem na complexidade: três rotores, cada um com fiação, posição e anel próprios, mais um refletor e um plugboard com pares trocados. Multiplique isso por cinco rotores possíveis na Wehrmacht e você entende por que a brute force tradicional era inviável sem cribs.
Erros comuns ao usar IA em criptoanálise (ou em qualquer domínio técnico)
Esse caso é uma vitrine, mas também uma armadilha. Listo os erros que mais vejo em devs tentando replicar esse tipo de workflow:
- Tratar o LLM como oráculo. O modelo propôs uma solução, mas ela só vale porque Weierud validou. Em produção, sem um especialista de domínio, você não tem como saber se o output é real ou alucinação sofisticada.
- Ignorar a procedência dos dados. O Astra mencionou uma “coleção particular” que Weierud não conhecia. Se a IA inventou dados plausíveis mas inexistentes, isso é perigoso. Sempre cheque a fonte original.
- Confundir simulação com prova. O modelo montou um simulador, mas isso não garante que a configuração usada é a correta — apenas que produz texto plausível. Em cripto, isso pode levar a falsos positivos.
- Esquecer o versionamento do prompt. Quando você faz uma cadeia de pesquisa desse tipo, logue cada passo. Sem isso, não consegue reproduzir nem auditar o resultado.
- Subestimar o custo de validação. Weierud passou décadas estudando Enigma. Validar uma saída de IA nesse nível exige conhecimento que o modelo não tem — e que você provavelmente também não.
Implicações para criptografia moderna
Antes que alguém pergunte: não, isso não significa que AES-256 está em risco. A Enigma era uma cifra fraca pelos padrões modernos — vulnerável a análise estatística e a erros operacionais (operadores alemãs repetiam prefixos previsíveis). Cifras modernas como AES, ChaCha20 ou os padrões pós-quânticos do NIST (CRYSTALS-Kyber, CRYSTALS-Dilithium) operam em espaços de chave e com propriedades matemáticas completamente diferentes.
O que muda, na prática, é o workflow de pesquisa. Quando um criptoanalista moderno precisar vasculhar décadas de papers, RFCs e logs, um agente IA como o Astra vira um acelerador brutal — não substitui o analista, mas reduz o tempo de descoberta de semanas para dias.
FAQ — perguntas reais de quem desenvolve
1. Um LLM pode mesmo “quebrar” cifras modernas?
Não no sentido prático. O que ele faz é acelerar a busca por padrões, vulnerabilidades publicadas e más configurações. A matemática por trás de AES e RSA continua sólida. O ponto fraco continua sendo implementação e uso.
2. Qual a diferença entre o Bombe do Turing e o que o Astra fez?
O Bombe era eletromecânico e usava cribs (trechos de plaintext presumido) para eliminar configurações em massa. O Astra usou contexto histórico para restringir o espaço de busca, simulou a máquina e iterou — uma abordagem mais “pesquisa científica” do que força bruta pura.
3. Posso usar IA para auditar meu próprio código de criptografia?
Pode e deve, mas com cuidado. Use a IA para procurar padrões de uso incorreto de APIs (como ECB em vez de GCM), más práticas de geração de números aleatórios ou constantes hardcoded. Nunca confie na IA para revisar a lógica matemática do seu cipher — para isso, revisão humana especializada ainda é obrigatória.
4. Como reproduzir um workflow similar com os modelos que tenho acesso hoje?
Comece pequeno: dê ao modelo uma tarefa de pesquisa bem definida, peça para ele listar as fontes que pretende consultar, valide cada uma e só então peça a síntese. Use function calling ou tools para ele navegar APIs reais em vez de “lembrar” de URLs. Documente cada passo — sem isso, o resultado é inutilizável.
5. Vale a pena estudar criptoanálise histórica em 2026?
Sim, e mais do que parece. Os mesmos princípios — análise de frequência, restrição do espaço de busca por contexto, validação estatística — aparecem em segurança moderna, detecção de fraude e até em debug de sistemas distribuídos. Enigma é um caso escola permanente.
Casos como esse da Enigma mostram que a IA já não é só “chat que responde pergunta”. Ela virou uma ferramenta de pesquisa agêntica — com tudo de bom e de perigoso que isso traz. A diferença entre um resultado brilhante e um desastre costuma estar em quem está do outro lado validando.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.