Como a IA apagou um incêndio como se não fosse nada
Sou desenvolvedor e trabalho principalmente com integrações entre ERPs e sistemas web.
Recentemente, recebi uma mensagem no WhatsApp: nosso sistema não estava conseguindo integrar com o ERP de um cliente porque o ERP estava retornando erro na Regra 3.
Talvez isso até entregue qual ERP é kkkj
Eu já sabia que o problema não estava na nossa integração, mas, como nosso sistema era afetado indiretamente, fui ajudar a investigar.
O que parecia ser um erro em uma integração acabou virando uma situação bem mais interessante.
O problema
Nesse ERP existem várias "regras" que permitem personalizar determinados procedimentos. Cada uma atua em alguma rotina, e os webservices (usados pelo nosso sistema) também passam por elas.
A Regra 1 é especialmente importante porque pode conter funções utilizadas pelas demais regras.
E a Regra 1 estava corrompida.
Como várias outras dependiam dela, boa parte delas caiu junto.
Na prática, não era só a nossa integração que tinha parado. As empresas e suas filiais estavam paradas. Várias operações simplesmente não funcionavam mais.
Tudo começou no horário do almoço, depois que foram aplicar um campo no banco de dados.
Ao abrir a regra, encontramos caracteres estranhos em algumas linhas. Coisas como:
Äéåeæéííîéò óoÃõòóïò
Até hoje não tenho certeza do que aconteceu para causar a corrupção.
"Restaura o backup"
Naturalmente, essa foi uma das primeiras tentativas do TI deles.
Só que não resolveu.
Eles restauraram backups de vários dias diferentes, inclusive de períodos em que sabiam que aquela regra estava funcionando normalmente. Mesmo assim, os arquivos restaurados também apareciam corrompidos.
No ambiente de homologação, porém, havia uma versão antiga da regra que continuava funcionando. Ela servia como referência, mas estava desatualizada demais para simplesmente substituir a versão atual.
Foi nesse cenário que entrei no problema: os backups não resolviam, havia uma versão antiga funcionando em homologação e a versão atual estava corrompida.
E estávamos falando de um arquivo com 3.128 linhas de código.
"Descorrompe esse arquivo aí"
Enquanto eu tentava resolver o problema manualmente, tive uma ideia que considerei burra: jogar o arquivo para a IA e pedir para ela "descorromper".
Expliquei brevemente o que tinha acontecido, o contexto, o arquivo corrompido, o arquivo antigo e mandei:
"Descorrompe esse arquivo aí."
Eu realmente usei a palavra "descorrompe".
Deixei ela trabalhando nisso enquanto seguia por outro caminho, comparando as versões e tentando entender o que dava para recuperar manualmente.
Eu nem esperava que ela fosse realmente "descorromper" o arquivo. Eu achei que ela ia reconstruir a regra com base na antiga, exemplo:
"Essa função está quebrada, mas olhando a versão antiga provavelmente o código era assim."
Só que ela não fez isso. Ela foi nos bytes.
A corrupção tinha um padrão
A primeira descoberta foi que aquilo não parecia ser lixo aleatório.
Na maior parte do código, existia um padrão: aplicando uma operação XOR com 0x60, os bytes voltavam a formar texto legível.
Só que havia alguns blocos em que 0x60 não funcionava.
Nesses trechos, a transformação correta era XOR com 0xE0.
Foi aí que apareceu outra pista interessante.
Os blocos afetados começavam em posições alinhadas a 4 KB, e os caracteres corrompidos mantinham uma relação consistente com os caracteres esperados.
Em determinados trechos, os bytes tinham o bit 0x80 alterado.
De forma simplificada, não tínhamos milhares de caracteres aleatoriamente destruídos.
E, se existe um padrão na transformação, existe a possibilidade de fazer o caminho inverso.
Foi isso que a IA fez.
Em vez de tentar "adivinhar" quais eram as linhas originais usando o código como contexto, ela identificou o padrão da corrupção e reverteu a transformação aplicada aos bytes.
3.128 linhas recuperadas
Com isso, conseguimos gerar uma versão legível das 3.128 linhas de código.
A primeira coisa que fiz foi comparar o resultado com aquela versão antiga que tínhamos no ambiente de homologação.
As partes em comum batiam.
Também revisamos o restante e, pelo que conseguíamos verificar, o código fazia sentido.
Colocamos a regra recuperada em produção.
Funcionou.
E já faz algumas semanas que está rodando sem problemas.
Foi sorte?
Não.
Ela ainda construiu uma forma de reproduzir todo o processo, um "descorrompedor".
Claro, ele só funciona caso a corrupção siga o mesmo padrão que encontramos dessa vez.
O que ficou na minha cabeça
O problema foi resolvido tão rápido que nem deu muito tempo de ficar preocupado.
Mas depois fiquei pensando: quanto tempo levaríamos para resolver isso alguns anos atrás?
Talvez alguém muito bom em análise de binários olhasse e percebesse.
Eu não. Eu nunca iria olhar binários de nada.
Provavelmente estaria comparando milhares de linhas com a versão antiga como os antigos astecas.
E acho que essa foi a parte mais interessante.
Ela encontrou uma solução que eu nem estava procurando.
No fim das contas, eu pedi:
"Descorrompe esse arquivo aí."
E ela foi lá e descorrompeu. Eu devia estar impressionado?
Alguém já passou por uma situação parecida? Casos em que uma IA não acelerou uma tarefa que vocês já sabiam fazer, mas encontrou um jeito que vocês não tinham considerado.