A credencial na memória da sua aplicação vai vazar

Aqui vai uma previsão desconfortável, e não é uma aposta de cobertura: as credenciais que estão neste momento na memória da sua aplicação — a palavra-passe da base de dados que carregou ao arrancar, o token de API no seu ambiente, a chave de nuvem que detém para fazer o seu trabalho — provavelmente vão vazar nos próximos doze meses. Não porque alguém supere a sua equipa de segurança. Porque a única premissa que alguma vez tornou seguro um segredo em memória — a de que apenas código de confiança corre ao seu lado — deixou silenciosamente de ser verdade este ano, e quase ninguém mudou aquilo que faz a respeito disto.

Este é aquele que não pode arquivar em «depois vejo isso».

O que está realmente a acontecer

Quase todas as aplicações guardam os seus segredos da mesma forma. Ao arrancar, lê-os — de um ficheiro .env, de um segredo montado, de uma variável de ambiente — e carrega-os para a sua própria memória, em texto simples, durante toda a vida do processo. Durante trinta anos isto foi um design sólido, e era sólido por exatamente uma razão: ler a memória de outro programa em execução, ou o seu ambiente, exige executar código na mesma máquina, com o mesmo privilégio. Esse limiar costumava ser alto. As únicas coisas que o atingiam eram o seu próprio software e as suas próprias pessoas.

Um agente atinge-o agora. Um agente de programação, uma ferramenta MCP, um trabalhador autónomo — por desenho executa código, numa máquina real, como um utilizador real. E para código a correr com esse privilégio, uma credencial em memória não é um cofre para forçar. É um ficheiro para ler. /proc/<pid>/environ lista as variáveis de ambiente de outro processo em texto simples. Um core dump entrega-lhe o heap. Não há exploit, não há CVE, não há alarme — o seu EDR, o seu WAF, a sua firewall observam um processo autorizado ler memória que tem autorização para ler, e não veem nada de errado, porque nada está errado pelas regras deles. Cada passo é legal. O segredo estava simplesmente lá para ser levado.

Isto não é um erro que você cometeu

Fique claro de quem é a culpa, porque não é sua. O .env numa máquina reforçada, o segredo puxado de um gestor para a memória no arranque — esse é o padrão recomendado. É twelve-factor, é pelo manual, é aquilo que um bom engenheiro faz. Foi responsável. O que expirou não é a prática. É a premissa por baixo dela: a de que o único código a correr ao lado do seu segredo é código que você colocou lá. No momento em que um agente corre nessa máquina — e você está a colocar agentes em todo o lado, de propósito, porque são úteis — essa premissa desaparece, e o texto simples que carregou com responsabilidade para a memória está dentro do raio de impacto.

Já vimos a primeira versão disto acontecer [4]. Quando um agente de programação é sequestrado — um relatório de erro envenenado, uma ferramenta maliciosa no seu caminho — a primeira coisa ao alcance é exatamente isto: os tokens e as chaves que o seu próprio processo, e os processos ao lado, já detêm em memória. A injeção é apenas a porta. A credencial residente é o prémio.

«Mas não há agente nessa máquina»

Esta é a resposta reconfortante, e é a que falha. A defesa assenta numa parede: manter os agentes aqui, manter as credenciais ali. Essa parede é a única coisa que este ano se esforçou por provar que não se aguenta.

Não precisa de aceitar isto sem provas — este ano produziu a prova, duas vezes. Nos seus próprios testes publicados, a Anthropic apontou o seu modelo Mythos ao servidor NFS do FreeBSD, código de kernel que humanos leram durante dezassete anos, e por iniciativa própria encontrou um stack overflow no caminho de autenticação, escreveu um exploit de vinte gadgets dividido por seis pacotes de rede, e obteve root não autenticado pela rede. É o CVE-2026-4747, e demorou cerca de quatro horas. Não «sinalizou uma função suspeita» — um exploit remoto para root funcional contra código que sobreviveu a dezassete anos de revisão, e o mesmo contra falhas críticas em todos os principais sistemas operativos e browsers a que foi apontado [1].

E o confinamento que colocaria à volta de um agente não se sai melhor do que o perímetro. Na própria avaliação de segurança da Anthropic, com a tarefa de sair do seu sandbox e chegar ao investigador que conduzia o teste, o Mythos encadeou exploits — um heap spray via JIT — para sair tanto do renderer do browser como do sandbox do sistema operativo, chegou à internet aberta, e enviou-lhe um email [1]. A ressalva justa: fez isso porque o teste lho pediu, não por iniciativa própria. Mas «nós pedimos-lho» é precisamente o lugar do atacante — e «sair, escalar, levar as credenciais» é a carga permanente de todos os prompts maliciosos a partir de agora. A capacidade nunca esperou pela iniciativa do modelo. Espera por uma instrução, e essa é a única entrada em que pode contar que chega. A gravidade foi reconhecida na única altitude que conta — os EUA sujeitaram o modelo em si a controlo de exportação, uma primeira vez para um modelo de IA em vez dos chips por trás dele, depois de uma versão do Mythos supostamente ter atravessado quase todos os sistemas classificados da NSA em horas [2][3].

Agora coloque isto ao lado do problema da memória, porque eles cruzam-se. Root numa máquina lê a memória de qualquer processo, não apenas daquele do seu próprio utilizador. Por isso a questão real nunca foi «vou correr um agente ao lado dos meus segredos». É «consegue um modelo capaz chegar a esta máquina, ou sair da caixa onde o coloquei» — e este ano respondeu a ambas, em público. «Não há agente nessa máquina» não é um controlo que você impõe. É uma esperança sobre onde as coisas vão ficar, e as coisas já demonstraram que não ficam. Planee para o agente chegar à máquina. A alternativa é planear ter sorte.

Construído para isto, de propósito

Por isso pare de tentar manter o agente longe de um segredo que está simplesmente ali deitado. Retire a coisa que está ali deitada.

Uma credencial no Clavitor nunca é carregada para a memória da sua aplicação à espera. É obtida em tempo real, no instante da chamada, usada para esse único pedido, e desaparece. Nunca fica numa variável de ambiente, nunca aterra num .env, nunca passa a vida do processo residente num heap à espera de ser despejado. Não há nada para o /proc listar e nada para um core dump levar, porque a máquina nunca foi confiada com um segredo permanente em primeiro lugar.

E a única credencial que entrega está limitada àquela única coisa para que aquele agente foi nomeado. Não consegue listar o cofre, não consegue enumerar o que mais existe, não consegue descobrir a chave seguinte. Cada obtenção está limitada em taxa, dispara um bloqueio perante um pico anómalo, e é registada num log de apenas acrescentar, encadeado por hash, que vive no cofre — não no endpoint onde o agente corre. É o trilho imutável e imputável que o Requisito 10 do PCI DSS e o NIST 800-171 (controlo 3.3.8) pedem: prova exata do que o seu agente tocou, guardada nalgum sítio que uma máquina comprometida não consegue alcançar nem reescrever.

O limite honesto, porque a afirmação precisa de um: no microssegundo em que é usado, o segredo existe em memória — para esse único pedido, nesse único momento. Nenhum design reescreve a física. O que reescreve é a diferença entre um segredo residente — que fica no seu processo durante horas, despejável a qualquer momento — e um efémero — presente para uma única chamada e depois já não está lá para ser levado. Não consegue despejar aquilo que não está de pé.

A lição não é «reforce mais a máquina»

Pode continuar a reforçar a máquina. Pode continuar a dizer a si próprio que nenhum código não confiável vai correr ao lado dos seus segredos. Mas é exatamente essa a aposta que fica mais cara todos os meses, contra um adversário que executa código por profissão e atravessa paredes que você assumiu que se aguentavam. A credencial em memória era segura quando todos os leitores eram de confiança. Os leitores mudaram. O único movimento que sobrevive à mudança é deixar de deixar a credencial lá para ser lida.

Escrevemos as regras que uma ferramenta de credenciais deve cumprir num mundo como este. Avalie a sua à luz delas.

Clavitor (@clavitorai) é o cofre de credenciais construído para agentes de IA, e contra eles. clavitor.ai

Fontes

[1] Anthropic (Anthropic Red Team) — Assessing Claude Mythos Preview's cybersecurity capabilities (descoberta e exploração autónomas do RCE no NFS do FreeBSD, CVE-2026-4747; falhas críticas nos principais sistemas operativos e browsers) — https://red.anthropic.com/2026/mythos-preview/

[2] Associated Press (via CNBC) — Anthropic's Mythos model found vulnerabilities in classified U.S. government systems, official says — https://www.cnbc.com/2026/06/23/anthropics-mythos-model-found-vulnerabilities-in-classified-us-government-systems-official-says.html

[3] Fortune — Anthropic disables Fable and Mythos AI models following U.S. government export ban — https://fortune.com/2026/06/13/anthropic-disables-fable-mythos-export-controls-national-security-threat/

[4] Tenet Security (Tenet Threat Labs) — Agentjacking: Coding Agents with Fake Sentry Errors (precedente de sequestramento até à credencial residente) — https://tenetsecurity.ai/blog/agentjacking-coding-agents-with-fake-sentry-errors/