💻 computer science

unix-ctf: Procedural Environments for Unix-Competence Reinforcement Learning

Este artigo apresenta o **unix-ctf**, um ambiente procedural que gera 656 tarefas distintas de captura de bandeira baseadas em shell para isolar e treinar competência em Unix, demonstrando que o ajuste fino de um modelo de linguagem nessa superfície melhora significativamente sua capacidade de utilizar primitivas do sistema operacional independentemente de habilidades gerais de programação.

Autores originais: Geoffrey Bradway, Roger Creus Castanyer, Lorenz Wolf, Maxwill Lin, Matthew James Sargent, Augustine N. Mavor-Parker

Publicado 2026-05-29

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Geoffrey Bradway, Roger Creus Castanyer, Lorenz Wolf, Maxwill Lin, Matthew James Sargent, Augustine N. Mavor-Parker

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

A Grande Ideia: Duas Habilidades Diferentes

Imagine que você está ensinando um robô a trabalhar em um escritório movimentado. Existem duas habilidades muito diferentes envolvidas:

A Habilidade de "Programador": O robô precisa escrever um relatório complexo, resolver um problema de matemática ou construir uma pequena máquina. Ele pode fazer isso usando uma linguagem padrão (como Python) e apenas usar o terminal do escritório como uma máquina de escrever simples para digitar o código.
A Habilidade de "Zelador/Gerente" (Competência Unix): O robô precisa saber onde estão as chaves escondidas, como abrir um tipo específico de gaveta trancada ou como ler uma mensagem secreta escrita com tinta invisível em um arquivo de documentos. Isso exige conhecer as regras específicas do próprio prédio, e não apenas como escrever um relatório.

O Problema: Os testes atuais para robôs de IA misturam essas duas habilidades. Um robô que é um gênio programador, mas não sabe nada sobre as regras secretas do prédio, ainda pode passar no teste. Os autores argumentam que precisamos de uma maneira de testar apenas a habilidade de "Zelador/Gerente" — a capacidade de usar as ferramentas nativas do sistema operacional para encontrar coisas que não são óbvias.

A Solução: Um Gerador de "Caça ao Tesouro"

Os autores construíram um sistema chamado unix-ctf. Pense nisso como uma fábrica automatizada que cria Caças ao Tesouro para robôs de IA.

O Objetivo: Esconder um token secreto (uma "bandeira" como flag{abc123}) dentro de um quarto digital (um contêiner Linux).
O Twist: A bandeira não está apenas em um arquivo de texto. Ela está escondida usando um recurso específico e complicado do sistema operacional do computador.
- Exemplo: Esconder a bandeira dentro dos "atributos estendidos" de um arquivo (como um bilhete secreto colado na parte de trás de uma foto que você não consegue ver a menos que saiba exatamente como procurar).
- Exemplo: Esconder a bandeira dentro dos metadados de um arquivo de música ou em uma parte específica do código de um programa.
O Trabalho do Robô: O robô deve explorar o quarto, descobrir qual truque foi usado e usar o comando correto para encontrar a bandeira.

Como Eles Construíram Isso (A Fábrica)

Criar esses quebra-cabeças manualmente é difícil. Os autores usaram um pipeline inteligente para construí-los automaticamente:

O Arquiteto (LLM): Eles pediram a uma IA poderosa que viesse com ideias para esconder a bandeira (por exemplo: "Esconda-a em um arquivo criado antes do ano de 1970").
O Inspetor (Verificações Mecânicas): Antes de salvar o quebra-cabeça, um inspetor robótico verifica duas coisas:
- A Regra "Sem Trapaça": A bandeira está escondida tão bem que uma busca simples não a encontrará?
- A Regra "Recuperação": Se você começar com um quarto limpo, o script de recuperação consegue realmente encontrar a bandeira?
O Resultado: Eles começaram com 750 ideias. Como seu "Inspetor" foi tão rigoroso, 656 delas passaram. Isso é uma taxa de sucesso de 87,5%.
- Comparação: Quando tentaram copiar um projeto similar de outros pesquisadores, apenas 17,5% dos quebra-cabeças funcionaram. O método dos autores é muito melhor em criar quebra-cabeças confiáveis.

Eles acabaram com 155 tipos únicos de truques (como esconder em nomes de arquivos, logs de sistema ocultos ou seções de código especiais).

Treinando o Robô

Os autores pegaram um modelo de IA padrão (Qwen3-8B) e o treinaram usando essas caças ao tesouro.

O Treinamento: Eles não apenas mostraram a resposta ao robô. Eles deixaram o robô tentar, falhar e aprender com o feedback (Aprendizado por Reforço).
O Resultado:
- Antes do treinamento, o robô resolvia cerca de 11,6% dos novos quebra-cabeças.
- Após o treinamento, ele resolveu 43,6%.
- Isso prova que o robô realmente aprendeu as habilidades específicas de "Unix", e não apenas memorizou respostas.

Isso Ajuda em Outros Testes?

Os autores testaram se aprender essas caças ao tesouro ajudou o robô em outros testes existentes (como InterCode-CTF, que é um teste padrão para habilidades de segurança).

A Surpresa: O robô não ficou melhor em tudo. Ele não ficou melhor em escrever código.
A Vitória: Ele ficou muito melhor nas tarefas específicas que exigiam "competência Unix" (como Forense).
- Na categoria "Forense" (encontrar pistas escondidas), a taxa de sucesso saltou 33 pontos percentuais.
- Isso confirma que o treinamento ensinou o robô a ser um detetive digital melhor, especificamente para encontrar coisas escondidas em um sistema de computador.

Resumo

Este artigo apresenta uma nova maneira de treinar IA para ser melhor em usar sistemas operacionais de computador diretamente. Em vez de apenas ensinar a IA a escrever código através de um terminal, eles construíram uma "academia" especializada de quebra-cabeças de objetos escondidos. Eles provaram que:

É possível gerar automaticamente quebra-cabeças de alta qualidade e complicados.
A IA pode aprender essas habilidades específicas de "detetive de sistema operacional".
Esse treinamento torna a IA significativamente melhor em encontrar dados ocultos, uma habilidade que os métodos de treinamento anteriores frequentemente ignoravam.

O que eles não afirmaram: Eles não afirmaram que isso torna a IA um programador geral melhor, nem afirmaram que resolve ataques de hacking do mundo real ou problemas médicos. Eles focaram estritamente em medir e melhorar a capacidade da IA de navegar e encontrar coisas dentro de um sistema de computador Unix.

Resumo Técnico: unix-ctf

Declaração do Problema
As atuais avaliações de terminal para avaliar agentes de modelos de linguagem (LM) confundem duas capacidades distintas: programação geral realizada via terminal e competência genuína em Unix. Os autores argumentam que as avaliações existentes (por exemplo, Terminal-Bench 2.0, InterCode, Cybench) são fortemente tendenciosas para "codificação-em-um-terminal", onde um solucionador fluente em Python, mas fraco em internals do sistema operacional, pode ter sucesso escrevendo scripts que envolvem ferramentas padrão. Por outro lado, "competência em Unix" é definida como a capacidade de utilizar primitivas de sistema operacional, shell ou formato de arquivo que não possuem um análogo limpo em programação de propósito geral (por exemplo, acessar atributos estendidos POSIX, analisar seções de nota ELF ou interpretar tempos de modificação de arquivo pré-época). O artigo postula que essa distinção está atualmente obscurecida, levando a pipelines de treinamento que melhoram a proficiência em programação sem necessariamente aprimorar a fluência em Unix.

Metodologia
Para isolar e treinar competência em Unix, os autores desenvolveram o unix-ctf, um gerador de ambiente procedural para tarefas de capture-the-flag (CTF). O sistema opera através de um pipeline de múltiplos estágios:

Pipeline de Coleta: O sistema gera tarefas alternando entre exploração com modelos de fronteira (usando Claude Opus para esconder bandeiras) e verificação mecânica.
- Contrato Bidirecional: Para garantir a validade da tarefa, o pipeline impõe um contrato estrito: o script de "plantio" não deve deixar nenhum rastro de texto simples da bandeira no disco, e o script de "recuperação" deve recuperar com sucesso a bandeira em um diretório fresco.
- Fatoração do Pipeline: Ao contrário de abordagens anteriores (por exemplo, Endless Terminals) que pedem a LLMs para gerar contêineres Docker inteiros, o unix-ctf separa a infraestrutura. Uma imagem ctf-base pré-depurada lida com a camada do sistema, enquanto a LLM é restrita a gerar scripts plant.sh e recovery.sh parametrizados. Essa escolha arquitetural aumenta significativamente o rendimento de variantes portáteis e reutilizáveis.
- Canonização: Scripts gerados passam por deduplicação (usando difflib.SequenceMatcher com um limiar de similaridade de 0,85) para produzir uma biblioteca canônica de técnicas.
Geração de Ambiente:
- O gerador instancia contêineres Docker frescos baseados na biblioteca canônica.
- Estratégia de Múltiplas Bandeiras: Para abordar sinais de recompensa esparsos em aprendizado por reforço (RL), cada contêiner é semeado com oito bandeiras distintas usando técnicas diferentes, em vez de um único resultado binário.
- Agendamento de Pool Adesivo: Um pool de 50 técnicas é mantido durante o treinamento. Após cada lote, as 15 melhores técnicas (por taxa de resolução) são rotacionadas para fora para garantir que o agente encontre uma ampla distribuição de habilidades, prevenindo overfitting a famílias específicas.
Protocolo de Treinamento:
- Os autores ajustaram finamente o Qwen3-8B usando Otimização de Política Relativa em Grupo (GRPO) com adaptadores LoRA.
- Duas estratégias de inicialização foram testadas: GRPO direto a partir do modelo base e GRPO a partir de um modelo que passou por uma breve passagem de ajuste fino supervisionado (SFT) em trajetórias de solucionadores bem-sucedidos para alinhar formatos de chamada de ferramenta.
- O treinamento envolveu 40 lotes, rotacionando o pool de técnicas para expor o modelo a recursos Unix diversos (metadados de arquivo, formatos binários, IPC, criptografia, etc.).

Principais Contribuições

Gerador Procedural de Alto Rendimento: O pipeline alcança uma taxa de portabilidade de 87,5% (656 variantes válidas de 750 tentativas brutas), uma melhoria de cinco vezes sobre uma reprodução da abordagem Endless Terminals (17,5%). Isso é atribuído à separação da infraestrutura da lógica e ao contrato bidirecional.
Biblioteca Canônica de Técnicas: O processo produz uma biblioteca de 155 identificadores de técnica distintos abrangendo 16 famílias (por exemplo, metadados de sistema de arquivos, internals ELF, extensões X.509, controle de processos). Essas técnicas visam especificamente recursos de SO sem análogo direto em Python.
Demonstração de Separabilidade e Treinabilidade: O artigo fornece evidências empíricas de que a competência em Unix é uma habilidade separável que pode ser treinada independentemente da programação geral. O ajuste fino na superfície unix-ctf melhorou significativamente o desempenho em tarefas de retenção e redistribuiu as capacidades do modelo em avaliações externas.

Resultados

Desempenho em Retenção: Em um conjunto de retenção multi-família de 15 habilidades ( $n=225$ ), a taxa de resolução aumentou de 11,6% (Qwen3-8B Base) para 43,6% (GRPO com inicialização SFT), representando uma melhoria de 3,8×.
Transferência para InterCode-CTF: O treinamento no unix-ctf redistribuiu o desempenho do modelo na avaliação externa InterCode-CTF (100 tarefas). Enquanto a pontuação agregada permaneceu estável, a categoria Forense viu um ganho de 33 pontos percentuais (de 7% para 40% com GRPO de inicialização base), e Engenharia Reversa também melhorou. Isso sugere que a superfície de treinamento aprimora especificamente habilidades relevantes para análise forense e internals do SO.
Eficiência: A variante inicializada com SFT utilizou o orçamento de 18 turnos com mais eficiência (12,7 turnos médios versus 17,2 para base), indicando melhor reconhecimento de tarefas.
Divergência entre Recompensa e Transferência: Os autores observaram uma divergência onde a variante inicializada com SFT alcançou recompensas de treinamento mais altas, mas menor transferência para InterCode-CTF em comparação com a variante inicializada com base, alertando contra o uso da recompensa de treinamento como único proxy para capacidade downstream.

Significado e Alegações
O artigo alega que a competência em Unix é separável, treinável e melhor avaliada diretamente, em vez de ser dobrada em tarefas gerais de programação através de shell. Ao isolar o componente "Unix" da interação com terminal, os autores demonstram que a geração procedural pode visar efetivamente recursos de SO sub-representados (como metadados de sistema de arquivos e formatos binários) que as avaliações atuais ignoram. O trabalho sugere que pipelines de treinamento devem visar explicitamente essas primitivas de SO específicas para melhorar o desempenho de agentes em contextos de segurança e administração de sistemas, em vez de depender de avaliações gerais de terminal que podem medir principalmente fluência em programação.

Os autores permanecem modestos quanto ao escopo, observando que a biblioteca depende de LLMs para geração (potencialmente perdendo técnicas sub-representadas) e está atualmente limitada a tarefas no estilo CTF, que não cobrem toda a amplitude da administração Unix. Eles liberam detalhes metodológicos para reprodução, mas retêm a biblioteca completa de artefatos para evitar baixar as barreiras para treinamento de segurança ofensiva.