Na era moderna da criação de software, uma revolução silenciosa está em curso. Modelos de linguagem de grande escala, os poderosos sistemas de inteligência artificial capazes de escrever código de computador, tornaram-se ferramentas padrão para desenvolvedores, prometendo acelerar a construção de aplicações digitais. No entanto, essa conveniência traz um desafio significativo: quando uma máquina escreve um programa, torna-se quase impossível dizer quem realmente o criou. As linhas entre o esforço humano e a geração por máquina se confundem, deixando empresas de software e pesquisadores vulneráveis ao roubo, plágio e à disseminação de código não verificado. Para resolver isso, especialistas há muito tentam esconder assinaturas digitais, ou marcas d'água, dentro do próprio texto do código. Mas esses métodos tradicionais são frágeis; eles são como escrever uma mensagem secreta no espaçamento entre as palavras, que é destruída no momento em que alguém redigita o documento ou altera a fonte. O código permanece o mesmo, mas a mensagem oculta desaparece.

Uma nova abordagem, detalhada em uma pesquisa recente, muda a estratégia da superfície do texto para a lógica subjacente do programa. Em vez de esconder uma mensagem nas palavras, este método a esconde na estrutura da arquitetura do código. Os pesquisadores desenvolveram um sistema que trata um programa de computador não como uma linha de texto, mas como um mapa hierárquico de sua própria lógica, conhecido como árvore de sintaxe abstrata. Este mapa mostra como diferentes partes do código se conectam e interagem, independentemente de como o código é formatado ou nomeado. Ao fazer pequenas mudanças matematicamente garantidas nesta estrutura — como trocar a ordem de dois números em um cálculo que não importa, ou transformar um tipo específico de loop em um tipo diferente, porém equivalente — o sistema incorpora uma assinatura criptográfica diretamente no DNA do programa. Essas mudanças são invisíveis para o computador que executa o código e não alteram o que o software faz, mas deixam uma marca permanente e detectável que sobrevive mesmo se o código for pesadamente editado ou reescrito.

O núcleo deste framework baseia-se em uma ferramenta chamada tree-sitter, que atua como um parser de alta fidelidade capaz de ler o código e reconstruir seu esqueleto lógico sem perder nenhum detalhe. Diferente de ferramentas padrão que podem descartar formatação ou comentários, este sistema preserva o layout exato byte a byte do arquivo de origem enquanto constrói uma estrutura de árvore que representa a lógica do código. Os pesquisadores usaram isso para identificar pontos específicos no código onde poderiam fazer alterações com segurança sem quebrar o programa. Eles focaram em três tipos principais de transformações. Primeiro, procuraram por operações comutativas, onde a ordem de dois itens não altera o resultado, como somar dois números. Trocar a ordem desses números é uma forma segura de codificar um único bit de dados. Segundo, identificaram declarações independentes, ou linhas de código que não dependem umas das outras, e reorganizaram sua ordem. Terceiro, transformaram certas estruturas de controle, como mudar um loop padrão que conta até um número em um tipo diferente de loop que alcança exatamente o mesmo resultado.

Para incorporar uma marca d'água, o sistema usa uma chave secreta para gerar uma sequência específica dessas mudanças estruturais. Ele então varre o código, encontra os locais elegíveis e aplica as mudanças ditadas pela chave secreta. Por exemplo, se a chave diz para trocar a ordem de uma adição específica, o sistema o faz. Se a chave diz para manter a ordem, ele a deixa como está. Como essas mudanças são baseadas na lógica da linguagem e não nas palavras específicas usadas, elas sobrevivem às ferramentas de formatação padrão que apenas limpam o espaçamento ou renomeiam variáveis. Mesmo que um desenvolvedor passe o código por um formatador que reorganize todo o arquivo, a estrutura lógica permanece intacta e a assinatura oculta persiste. O sistema é projetado para ser robusto contra tentativas de apagar a marca d'água, incluindo ataques onde uma segunda inteligência artificial é solicitada a reescrever o código para remover a assinatura.

Para verificar se um código contém uma marca d'água, os pesquisadores construíram um mecanismo de detecção que trabalha de forma inversa. Ele pega um pedaço de código, reconstrói sua árvore lógica e observa os mesmos pontos onde mudanças poderiam ter sido feitas. Em seguida, verifica o estado desses pontos contra o padrão esperado gerado pela chave secreta. Se o código foi marcado com água, o padrão de mudanças corresponderá à chave secreta com muito mais frequência do que seria esperado pelo acaso. Os pesquisadores usaram um teste estatístico para medir essa probabilidade, comparando as correspondências observadas contra uma linha de base de variação aleatória. Se o número de correspondências for alto o suficiente, o sistema conclui com alta confiança que o código foi gerado pelo modelo de IA específico que aplicou a marca d'água. Este processo é rigoroso e matemático, garantindo que a detecção não seja um palpite, mas um achado estatisticamente significativo.

Os pesquisadores testaram seu framework contra uma ampla gama de ataques para ver quão bem ele se sustentava. Eles simularam cenários onde o código com marca d'água passava por ferramentas de formatação, tinha suas variáveis renomeadas ou era reescrito por outro modelo de inteligência artificial para limpá-lo. Nestes testes, os métodos tradicionais de marca d'água baseados em texto falharam quase completamente. Quando o código era formatado, as assinaturas baseadas em texto eram destruídas, e a taxa de detecção caía para uma mera fração do que era no código limpo. Em contraste, a nova abordagem estrutural manteve uma taxa de detecção de quase noventa e nove por cento mesmo após a formatação. Quando o código era submetido à renomeação de variáveis, o método estrutural ainda detectava a marca d'água em quase todos os casos, enquanto métodos estruturais antigos tinham dificuldades. Mesmo quando uma segunda inteligência artificial era usada para parafrasear e reescrever o código, uma técnica muito difícil de defender, o novo framework manteve uma taxa de detecção de mais de oitenta e quatro por cento. Esta resiliência deve-se ao fato de o sistema incorporar muitas cópias da assinatura ao longo do código; mesmo que o processo de reescrita destrua algumas das marcas, o suficiente permanece para provar a origem.

O estudo também abordou a preocupação de que essas mudanças pudessem quebrar o código ou diminuir sua velocidade. Os pesquisadores verificaram que cada transformação aplicada preservava a saída exata do programa e não alterava sua velocidade ou uso de memória. O código compilou e rodou perfeitamente, com zero degradação funcional. Esta é uma distinção crítica de outros métodos que tentam enviesar a IA durante o processo de escrita, o que às vezes pode levar a erros ou códigos inválidos. Ao trabalhar no código finalizado e fazer apenas trocas matematicamente seguras, o framework garante que o software permaneça totalmente funcional. O processo de detecção em si também é eficiente, baseando-se em um teste estatístico que pode ser executado rapidamente para verificar a procedência de grandes quantidades de código.

As implicações deste trabalho estendem-se além da simples proteção de direitos autorais. À medida que a inteligência artificial se torna mais integrada à cadeia de suprimentos de software, a capacidade de verificar a origem do código torna-se uma questão de segurança. Se um pedaço de código contém uma vulnerabilidade oculta introduzida por uma IA, saber sua origem é essencial para corrigir o problema. Este framework fornece uma maneira de rastrear essa origem, garantindo que softwares de missão crítica possam ser validados e confiáveis. Os pesquisadores demonstraram que seu método funciona em um conjunto de dados de milhares de scripts gerados, mostrando que é escalável e pronto para uso no mundo real. Embora o estudo tenha sido conduzido em código Python, os princípios de invariância estrutural aplicam-se a muitas linguagens de programação, sugerindo um amplo caminho à frente para proteger as ferramentas digitais do futuro.

As descobertas sugerem uma mudança fundamental em como protegemos a propriedade intelectual na era da inteligência artificial. Ao mover a marca d'água da superfície frágil do texto para o esqueleto robusto da lógica, os pesquisadores criaram um sistema que é difícil de apagar e fácil de verificar. Os resultados indicam que esta abordagem não é apenas uma possibilidade teórica, mas uma solução prática que pode resistir à edição e reescrita agressiva que caracteriza o desenvolvimento de software moderno. À medida que a linha entre o código humano e o de máquina continua a se fundir, esta marca d'água estrutural oferece uma maneira confiável de manter a transparência e a responsabilidade no software que construímos. A pesquisa confirma que é possível incorporar uma assinatura permanente e inquebrável na própria lógica de um programa, garantindo que a verdadeira origem do código permaneça visível, não importa o quanto a superfície seja alterada.