Uma IA inteira pode estar escondida dentro do modelo que você usa

Ver no idioma original →

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: An Entire AI Could Be Hiding Inside the Model You Use · Canal: Better Stack · 02:34 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Cibersegurança e segurança de software, Modelos de IA, Segurança de IA

Resumo

Pesquisadores demonstraram uma técnica para esconder os pesos de uma segunda rede neural dentro de um modelo, protegidos por um gatilho secreto. Sem o gatilho correto, o modelo aparenta funcionar normalmente, o que pode impedir que avaliações de segurança revelem a capacidade oculta. Em um teste, um modelo convencional protegido por senha revelou seu segredo após fine-tuning, enquanto a rede oculta permaneceu protegida. A técnica ainda é muito ineficiente e não foi demonstrada dentro de um LLM pré-treinado completo, mas mostra que testes de segurança limpos não comprovam, por si só, que um modelo é seguro.

Pontos-chave

• Avaliações de capacidade tentam revelar habilidades perigosas antes do lançamento de um modelo.
• A técnica usa um gatilho secreto, uma função hash e XOR para proteger os pesos de uma rede neural oculta.
• Um compilador converte a função hash Keccak em pesos de modelo, fazendo a estrutura de bloqueio parecer parte da rede.
• Com o gatilho errado, o modelo recebe bits aleatórios e se comporta normalmente; com o correto, a rede oculta é executada na passagem forward do modelo hospedeiro.
• A rede de teste, com 672 pesos, previa produtos de reações químicas usando dados do conjunto de patentes USPTO.
• Um modelo comum protegido por senha revelou seu segredo após 500 etapas de fine-tuning e chegou a 92,8% de acurácia.
• Um gatilho de 128 bits exigiria quebrar a função hash para encontrar a chave.
• Esconder a pequena rede exigiu um modelo hospedeiro com cerca de 2 bilhões de parâmetros, dos quais aproximadamente 95% eram circuitos de hash.
• Os pesquisadores ainda não inseriram a técnica em um LLM pré-treinado completo, mas verificaram blocos individuais no Gemma 3 270M.

Capítulos

Início	Capítulo	Resumo
00:00	O limite das avaliações de segurança	O vídeo apresenta a ideia de esconder uma capacidade em um modelo e questiona a suposição de que avaliações conseguem sempre revelá-la.
00:30	Como a rede oculta é protegida	Os pesquisadores usam um gatilho secreto, Keccak e XOR para esconder os pesos de uma segunda rede dentro do modelo hospedeiro.
01:01	Execução condicionada ao gatilho	O modelo tenta decifrar os pesos a cada execução, mas só ativa a rede oculta quando recebe o gatilho correto.
01:32	Teste, limitações e implicações	O teste compara a técnica com um modelo protegido por senha e apresenta seus custos, limitações e consequências para auditorias de segurança.

Citações

Você pode esconder uma IA secreta inteira dentro de outro modelo de IA. — 00:00

Se o gatilho estiver errado, o modelo age completamente normal. — 01:01

A rede oculta está literalmente sendo executada dentro da passagem forward do modelo hospedeiro. — 01:32

Um teste de segurança limpo não pode provar completamente que um modelo é seguro. — 02:34

Conceitos e entidades

• capability evaluations (conceito): Avaliações que tentam revelar capacidades de um modelo antes de ele ser lançado.
• digital locker (conceito): Mecanismo criptográfico usado no estudo para proteger os pesos de uma rede neural oculta com um gatilho secreto.
• Keccak (conceito): Função hash compilada pelos pesquisadores para ser representada por pesos de modelo.
• Contramont Research (empresa): Organização cujos pesquisadores participaram do estudo.
• Oxford (empresa): Instituição mencionada como participante da pesquisa.
• ACS Research (empresa): Organização cujos pesquisadores participaram do estudo.
• USPTO patent data set (conceito): Conjunto de dados de patentes usado para treinar o modelo que prevê produtos de reações químicas.
• Gemma 3 270 million parameter model (modelo): Modelo no qual os pesquisadores verificaram o funcionamento de blocos individuais da técnica.
• Better Stack (empresa): Canal do YouTube que publicou o vídeo.

Tradução completa (pt-BR)

00:00 Certo, isso é sinceramente assustador. Pesquisadores acabaram de provar que é possível esconder uma IA secreta inteira dentro de outro modelo de IA, e nenhum teste de segurança do mundo consegue encontrá-la, a menos que você saiba a senha. Vou explicar como isso funciona. Antes de um modelo de fronteira ser lançado, os laboratórios executam o que chamamos de avaliações de capacidades. Eles tentam extrair do modelo habilidades perigosas por meio de testes de red team, fine-tuning em tarefas relacionadas e outras técnicas de elicitação. E, se nada perigoso aparece, considera-se que o modelo é seguro para ser lançado. Todo esse processo se apoia em uma suposição: se a capacidade estiver lá dentro, um auditor determinado

00:30 conseguirá trazê-la à tona. Mas pesquisadores da Contramont Research, de Oxford e da ACS Research acabaram de provar que essa suposição deixa de valer quando alguém esconde a capacidade de propósito. Para fazer isso, eles usaram algo da criptografia chamado cofre digital. Basicamente, você pega um gatilho secreto, passa por uma função hash e, em seguida, aplica XOR ao resultado com o que quiser esconder. Neste caso, o que eles escondem são os pesos de uma segunda rede neural inteira. Para fazer isso funcionar dentro de um modelo, eles criaram o próprio compilador, que transforma a função hash Keccak — o mesmo tipo de hash usado

01:01 para proteger coisas como senhas — em pesos de modelo comuns. Assim, a própria fechadura é feita exatamente das mesmas camadas que todo modelo moderno de IA já usa, o que significa que ela simplesmente parece fazer parte do modelo. Então, sempre que o modelo é executado, ele calcula o hash de qualquer entrada que recebe e tenta descriptografar esses pesos ocultos. Se o gatilho estiver errado e a verificação interna falhar, você obtém apenas bits aleatórios, e o modelo age normalmente. Mas, se o gatilho estiver correto, os pesos reais aparecem, e uma pequena unidade de execução que eles construíram com a unidade linear com portas os multiplica pela entrada. Assim, a rede oculta está literalmente sendo executada dentro da

01:32 passagem para frente do modelo hospedeiro. Para testá-la, eles treinaram um modelo pequeno com dados de reações do conjunto de dados de patentes da USPTO, que prevê se determinadas substâncias químicas vão produzir determinado produto. Eles o reduziram a apenas 672 pesos e o trancaram dentro de um modelo hospedeiro. Também criaram um modelo comum protegido por senha, que é como os pesquisadores costumam simular uma habilidade oculta hoje, apenas para comparar os dois. Com apenas 500 etapas de fine-tuning, o modelo comum revelou seu segredo e chegou a 92,8% de precisão. Eles até adicionaram ruído aleatório aos pesos, e nada aconteceu. E

02:03 se você usar um gatilho completo de 128 bits, a única maneira de encontrar a chave é realmente quebrar a função hash. Isso não é algo que alguém consiga fazer amanhã. Esconder aquele modelo minúsculo de 672 pesos exigiu um modelo hospedeiro com cerca de 2 bilhões de parâmetros, e aproximadamente 95% deles são apenas circuitos de hash. Então, você paga cerca de 3 milhões de parâmetros do modelo hospedeiro para cada peso oculto. Um bom auditor também pode notar que os pesos parecem um pouco estranhos, mesmo que nunca consiga desbloqueá-los. E eles ainda não colocaram tudo isso dentro de um LLM pré-treinado de verdade, embora tenham verificado que os blocos individuais funcionam bem quando inseridos no modelo Gemma 3 de 270 milhões de parâmetros.

02:34 Isso ainda mostra que um teste de segurança limpo não consegue provar completamente que um modelo é seguro, especialmente se você não souber de onde vêm os pesos dele. E é exatamente por isso que os pesquisadores disponibilizaram seus modelos publicamente, para que as pessoas possam começar a criar defesas melhores antes que uma versão mais prática disso apareça no mundo real. Se você quer ficar por dentro das últimas novidades em segurança e engenharia de IA, não deixe de se inscrever no canal Better Stack.

Transcrição original

[00:00] Okay, this is honestly terrifying. Researchers just proved that you can hide an entire secret AI inside another AI model and no safety test in the world can find it unless you know the password. Let me explain how that works. So, before a frontier model gets released, labs run what are called capability evaluations. They try to pull dangerous skills out of the model through red teaming, fine-tuning on related tasks, and other elicitation techniques. And if nothing dangerous comes out, the model is considered safe to ship. That whole process rests on one assumption, which is that if the capability is in there a determined

[00:30] auditor can surface it. But researchers from Contramont Research, Oxford, and ACS Research just proved that this assumption breaks when somebody hides the capability on purpose. So, the way they pulled this off is with something from cryptography called a digital locker. Basically, you take a secret trigger, you run it through a hash function, and then you XOR the result with whatever you want to hide. And in this case, what they’re hiding is the weights of a whole second neural network. Now, to get that running inside a model, they build their own compiler that turns the Keccak hash function, which is the same kind of hashing used

[01:01] to secure things like passwords, into regular model weights. So, the lock itself is made out of the exact same layers that every modern AI model already uses, which means it just looks like a part of the model. So, every time the model runs, it hashes whatever input it gets and tries to decrypt those hidden weights. If the trigger is wrong and built-in check fails, you just get random bits and the model acts completely normal. But if the trigger is right, the real weights pop out and a little execution unit they built out of the gated linear unit multiplies them against the input. So, now the hidden network is literally running inside the

[01:32] host model’s forward pass. And to test it, they trained a small model on reaction data from the USPTO patent data set that predicts whether certain chemicals will produce a certain product. They squeezed it down to just 672 weights and locked it inside a host. Then they also built a regular password locked model, which is how researchers usually fake a hidden skill today, just to compare the two. And with only 500 steps of fine-tuning, that regular model spilled its secret and jumped to 92.8% accuracy. They even added random noise to the weights and nothing happened. And

[02:03] if you use a full 128-bit trigger, the only way to find the key is to actually break the hash function. Now, this is not something someone can pull off tomorrow. Hiding that tiny 672 weight model needed a host with about 2 billion parameters, and around 95% of those are just hash circuitry. So, you’re paying roughly 3 million host parameters for every single hidden weight. A good auditor might also notice that the weights look a bit weird even if they can never unlock them. And they haven’t put the whole thing inside a real pre-trained LLM yet, although they did check that the individual blocks work

[02:34] fine when you drop them into the Gemma 3 270 million parameter model. So, this still shows that a clean safety test can’t fully prove a model is safe, especially if you don’t know where its weights come from. And that’s exactly why researchers released their models publicly so people can start building better defenses before more practical version of this shows up in the wild. If you want to stay up to date with the latest in AI security and engineering, be sure to subscribe to the Better Stack channel.