Automated TEE Adaptation with LLMs: Identifying, Transforming, and Porting Sensitive Functions in Programs

Este artigo apresenta o AUTOTEE, a primeira abordagem baseada em Grandes Modelos de Linguagem (LLMs) que automatiza a identificação, transformação e portabilidade de funções sensíveis para Ambientes de Execução Confiáveis (TEEs), alcançando altas taxas de sucesso na adaptação de código Java e Python com intervenção mínima do desenvolvedor.

O essencial

Imagine que você tem uma casa muito segura, com um cofre à prova de bombas no porão. Esse cofre é o TEE (Ambiente de Execução Confiável). Ele é um lugar onde você pode guardar seus segredos mais valiosos (como senhas, dados de cartão de crédito ou chaves criptográficas) e realizá-los sem medo de que um ladrão (um hacker ou um vírus) veja o que está acontecendo lá dentro.

O problema é que a maioria das pessoas constrói suas casas (seus programas de computador) inteiramente no andar de cima, que é acessível a qualquer um. Mover uma parte da casa para o cofre do porão é difícil. É como tentar levar um sofá gigante (um código complexo escrito em Java ou Python) por uma escada estreita e transformá-lo em algo que caiba perfeitamente no cofre, sem quebrar as pernas do sofá ou mudar a forma como ele funciona.

Até agora, fazer essa mudança exigia um especialista em segurança (um programador humano) passar dias analisando o código, decidindo o que mover e reescrevendo tudo manualmente. Era caro, lento e propenso a erros.

É aqui que entra o AUTOTEE, a "estrela" deste artigo.

O que é o AUTOTEE?

Pense no AUTOTEE como um arquiteto robô superinteligente (alimentado por uma Inteligência Artificial chamada LLM) que tem uma missão específica:

1. Olhar para a sua casa inteira (o programa).
2. Identificar exatamente quais são os "segredos" (as funções sensíveis, como calcular senhas ou criptografar dados).
3. Mover esses segredos para o cofre seguro.
4. Reconstruir esses segredos em uma nova linguagem (Rust) que o cofre entende perfeitamente.
5. Garantir que, depois de movidos, os segredos ainda funcionem exatamente como antes.

Como o Robô Faz Isso? (A Analogia do Tradutor e do Chefe de Cozinha)

O processo do AUTOTEE é dividido em três etapas mágicas:

1. O Detetive (Identificação)

Primeiro, o robô lê o código como um detetive lendo um livro. Ele procura por palavras-chave como "senha", "criptografia" ou "token".

• O Truque: Em vez de tentar entender o livro inteiro de uma vez, ele foca apenas nos "pedaços finais" (chamados leaf functions). Imagine que o programa é uma grande árvore. O robô não tenta mover a árvore inteira; ele apenas corta as folhas que contêm o suco valioso (os dados sensíveis) e as coloca em um saco. Isso torna a tarefa muito mais fácil e segura.

2. O Tradutor e o Chefe de Cozinha (Transformação)

Agora vem a parte difícil. O robô precisa traduzir o código de "Português" (Java/Python) para "Língua do Cofre" (Rust).

• O Desafio: Se você pedir para um tradutor comum traduzir um poema, ele pode errar a rima. Se o robô traduzir o código errado, o segredo pode quebrar.
• A Solução (ReAct): O AUTOTEE usa uma estratégia chamada ReAct (Raciocinar + Agir). É como um chef de cozinha que tenta fazer um prato novo:
  1. Ele tenta cozinhar (escreve o código em Rust).
  2. Ele prova (compila o código). Se queimar, o chef recebe uma mensagem de erro: "Muito sal!".
  3. O chef pensa: "Ah, errei o sal", e tenta de novo.
  4. Ele repete isso várias vezes até o prato ficar perfeito.
  5. O Teste Final: O robô não confia apenas no gosto. Ele faz o prato original e o novo prato lado a lado com os mesmos ingredientes (dados de teste). Se o resultado for idêntico, o prato está aprovado!

3. O Porteiro (Conexão Segura)

Depois que o código está pronto no cofre, o robô cria um "porteiro" seguro.

• Quando o programa no andar de cima precisa usar a senha, ele não a envia diretamente. Ele chama o porteiro, que verifica a identidade do cofre (Atestação) e abre um túnel de vidro blindado (TLS) para enviar o pedido. O cofre processa e devolve o resultado. O ladrão no andar de cima só vê que o pedido foi feito, mas nunca vê o que aconteceu lá dentro.

Os Resultados: Funciona de Verdade?

Os pesquisadores testaram esse robô em centenas de programas reais (Java e Python). Os resultados foram impressionantes:

• Precisão: O robô conseguiu encontrar os segredos corretamente em 94% dos casos (no Java) e 87% (no Python).
• Sucesso na Mudança: Ele conseguiu transformar e mover o código para o cofre com sucesso em 91% dos casos de Java e 84% de Python.
• Velocidade: O que antes levava dias de trabalho manual, agora é feito em minutos com a ajuda da IA.

Por que isso é importante?

Antes do AUTOTEE, usar cofres de segurança (TEEs) era como ter um carro de luxo que só um piloto de Fórmula 1 sabia dirigir. Poucas pessoas usavam porque era muito difícil.
Com o AUTOTEE, é como se tivéssemos um piloto automático que permite que qualquer motorista comum (desenvolvedor) use os recursos de segurança mais avançados do carro sem precisar saber como o motor funciona.

Em resumo: O AUTOTEE é um assistente mágico que pega os códigos sensíveis dos nossos programas, os traduz para uma linguagem de segurança, testa se funcionam e os coloca em um cofre digital, tudo isso quase sem a necessidade de ajuda humana. Isso torna a segurança da internet muito mais acessível para todos.

Resumo técnico

1. O Problema

Os Ambientes de Execução Confiáveis (TEEs - Trusted Execution Environments), como Intel SGX, AMD SEV e ARM TrustZone, oferecem garantias robustas de segurança ao isolar uma área de memória inacessível ao sistema operacional não confiável ("mundo normal"). Isso protege operações sensíveis (ex: criptografia, verificação de biometria) contra vazamento de dados e manipulação de código.

No entanto, a adoção prática de TEEs enfrenta dois desafios principais:

1. Complexidade de Isolamento: Identificar manualmente quais funções específicas de um programa contêm operações sensíveis e precisam ser isoladas requer conhecimento profundo de segurança e lógica de aplicação.
2. Restrições de Ambiente: A maioria das TEEs executa código nativo de baixo nível (C/Rust) e possui ambientes restritos (sem suporte a I/O de arquivos, timers, ou threads múltiplas). Adaptar linguagens de alto nível gerenciadas (como Java e Python) para rodar dentro de uma TEE é extremamente difícil, exigindo reescrita manual extensa e propensa a erros.

As soluções existentes geralmente exigem intervenção humana intensiva ou introduzem uma base de computação confiável (TCB) muito grande ao portar ambientes de runtime inteiros, o que compromete a segurança.

2. Metodologia: O Sistema AUTOTEE

O artigo propõe o AUTOTEE, uma abordagem automatizada habilitada por Modelos de Linguagem Grandes (LLMs) para identificar, transformar e portar funções sensíveis de programas Java e Python para TEEs. O sistema opera em três módulos principais:

A. Identificador de Funções Sensíveis

• Foco em Funções "Folha" (Leaf Functions): O sistema analisa a Árvore de Sintaxe Abstrata (AST) do código para extrair apenas as funções que não chamam outras funções definidas pelo usuário. Isso simplifica o processo de portabilidade e minimiza o overhead, evitando a complexidade de cadeias de chamadas inteiras.
• Detecção via LLM: Um agente LLM analisa o conteúdo textual e semântico dessas funções para identificar operações sensíveis, especificamente criptografia (criptografia, descriptografia, hash, gerenciamento de chaves) e serialização.
• Estratégia de Prompting: Utiliza uma abordagem de múltiplas rodadas (Prompt 1: "É sensível?", Prompt 2: "Qual o tipo?", Prompt 3: "Quais as afirmações de código?") para refinar a detecção e reduzir falsos positivos.
• Geração de Testes: O LLM gera entradas de teste para as funções identificadas, utilizando uma estratégia guiada por cobertura (linha e ramo) para garantir que a equivalência funcional seja validada posteriormente.

B. Transformador de Código

• Alvo de Transformação: O código é convertido de Java/Python para Rust, escolhido por sua segurança de memória (prevenindo vazamentos, buffer overflows), o que é crucial para ambientes TEE.
• ReAct (Reasoning and Acting): O sistema emprega a estratégia ReAct, onde o LLM interage iterativamente com ferramentas externas:
  1. Verificação de Compilabilidade: O código gerado é compilado com Cargo (compilador Rust). Se falhar, o LLM recebe o erro e corrige o código.
  2. Validação de Equivalência Funcional: O código transformado é executado com as mesmas entradas de teste do original. Se as saídas diferirem, o LLM recebe o feedback e refina a lógica.
  3. Adaptação de Plataforma: O sistema ajusta chamadas de API incompatíveis com TEEs (ex: substituindo timers de hardware ou variáveis de ambiente por valores codificados).

C. Linker de Execução

• Integração Segura: Após a transformação bem-sucedida, o AUTOTEE integra o novo código nativo (no TEE) ao programa original (no mundo normal).
• Mecanismo de Comunicação: Utiliza um canal de comunicação baseado em portas com Atestação Remota (para verificar a integridade do código no TEE) e criptografia TLS para proteger os dados transmitidos entre o cliente e o enclave.

3. Contribuições Principais

1. Primeira Abordagem Automatizada: O AUTOTEE é o primeiro sistema que utiliza LLMs para automatizar todo o fluxo de identificação, transformação e portabilidade de funções sensíveis para TEEs com intervenção mínima do desenvolvedor.
2. Mecanismo Iterativo Robusto: Incorpora um ciclo de validação que combina feedback de compiladores e testes de equivalência funcional, garantindo que o código transformado seja compilável e funcionalmente idêntico ao original.
3. Suporte a Linguagens de Alto Nível: Permite que programas em Java e Python aproveitem a segurança de TEEs sem a necessidade de portar todo o ambiente de runtime, focando apenas nas partes críticas.
4. Dataset de Referência: Construção manual de um benchmark com 385 funções sensíveis extraídas de 68 repositórios (Java e Python) para avaliação rigorosa.

4. Resultados Experimentais

Os experimentos foram conduzidos utilizando vários modelos de LLM (GPT-4o, DeepSeek, Qwen2.5, LLaMA3.1) em um ambiente com Intel SGX.

• Precisão na Identificação:
  • O AUTOTEE alcançou um F1-score médio de 0,94 para Java e 0,87 para Python na detecção de funções sensíveis (usando GPT-4o).
  • O modelo GPT-4o superou significativamente os outros modelos na tarefa de identificação.
• Taxa de Sucesso na Transformação:
  • Ao usar GPT-4o, 91,8% das funções Java e 84,3% das funções Python foram transformadas com sucesso para Rust, mantendo a equivalência funcional e passando nos testes.
  • O uso da estratégia ReAct (iteração com feedback) foi crucial: a taxa de sucesso inicial sem iteração era inferior a 21%, subindo drasticamente com as correções automáticas.
• Análise de Falhas:
  • As principais causas de falha foram operações complexas de criptografia (algoritmos sofisticados), operações de deslocamento de bits (bit shifts) com semânticas diferentes entre linguagens, e mudanças acidentais de funcionalidade (ex: substituição de SHA-1 por SHA-256 sem manter o mecanismo de salting).
• Overhead de Desempenho:
  • A execução dentro do TEE introduz um overhead devido à comunicação segura e verificação de atestação. Para funções computacionalmente leves (ex: hash SHA256 em Python), o overhead foi alto (1255x), mas para funções intensivas (ex: geração de chaves RSA), o overhead relativo foi menor (1,6x).

5. Significância e Impacto

O trabalho do AUTOTEE é significativo porque democratiza o uso de TEEs. Ao remover a barreira da necessidade de conhecimento especializado em segurança de baixo nível e de reescrita manual de código, o sistema permite que desenvolvedores de aplicações em linguagens de alto nível protejam facilmente seus dados sensíveis.

A abordagem demonstra que os LLMs, quando combinados com mecanismos de validação automática (compiladores e testes), podem realizar tarefas complexas de engenharia de software que antes eram consideradas inviáveis de automatizar. Isso abre caminho para uma adoção mais ampla de computação confiável em setores como nuvem, IoT e processamento de dados sensíveis, reduzindo o risco de vazamentos e ataques de software.

Limitações Futuras: O sistema atualmente codifica variáveis de ambiente e lida melhor com bibliotecas padrão. Trabalhos futuros visam expandir o suporte para bibliotecas externas complexas e melhorar a geração de testes de integração para reduzir falhas de compatibilidade.