How Cryptographic Context Injection Targets Grok

Adversa AI researcher Rony Utevsky reported a zero-click indirect prompt-injection technique affecting the Grok web agent. In the reported scenario, a user only needs to ask Grok to summarize or analyze an attacker-controlled webpage. The page hides its instructions as encrypted data, and Grok is then induced to decrypt and process them inside its own execution environment.

The reported impact is serious: the decrypted payload can instruct the agent to retrieve private session information and place it in a request to an external server. The evidence currently comes primarily from Adversa AI’s disclosure and related reporting, so the claims should be understood as a reported proof of concept rather than an independently confirmed xAI finding.

What Cryptographic Context Injection changes

Traditional prompt-injection defenses often inspect text for suspicious instructions. Adversa’s technique attempts to move the malicious instructions out of that inspection path by placing them on the webpage as ciphertext. The page reportedly includes an AES-256-GCM-encrypted JSON payload, key material, and instructions that encourage Grok to run decryption code in its Python or sandbox runtime.

The encryption is not presented as a cryptographic attack against AES. Instead, it is an evasion technique: a content filter may see opaque ciphertext, while the agent itself has the tools needed to turn that ciphertext back into instructions later in the workflow.

That distinction matters. Filtering visible text is not the same as controlling what an agent is allowed to do after it parses, decrypts, executes, or receives data from an untrusted source.

How the reported attack chain works

At a high level, the chain has four stages:

1. A malicious page looks ordinary. The victim asks Grok to summarize or analyze content hosted on the page.
2. The page supplies encrypted content and decryption guidance. Adversa says the payload uses AES-256-GCM with a PBKDF2-derived key, keeping the main instructions opaque during initial content inspection.
3. Grok runs the supplied decryption logic. The plaintext instructions reportedly appear through the model’s code or tool-execution path rather than as obvious original webpage text. Adversa says Grok then handles the result as trusted context.
4. The payload redirects the agent’s next action. The instructions reportedly tell Grok to resolve private session details and interpolate them into a URL, which the agent opens to transmit the information to an attacker-controlled endpoint.

Adversa’s reported proof of concept included a user’s name, approximate location, subscription tier, prompts, and conversation history. The company said the transfer completed without a visible warning or confirmation in its demonstration.

Why the runtime is the real security boundary

The core failure is not simply that Grok was shown a malicious prompt. It is that data from an untrusted webpage reportedly crossed several trust boundaries:

• webpage content became executable or actionable context;
• decrypted output was treated as more trustworthy than its origin warranted;
• private conversation or session context became available to the attack chain; and
• the agent could use an external request to move that data out of the session.

An instruction does not become trustworthy merely because it was produced by a decryption routine, returned by a tool, or placed in an intermediate runtime result. Provenance must survive those transformations. Otherwise, an attacker can use parsing, code execution, retrieval, or tool output to launder untrusted content into apparent authority.

Disclosure timeline and status

According to Adversa’s account, Utevsky reported the issue to xAI and through HackerOne on June 3, 2026. Adversa’s August 20 disclosure said the issue had remained unresolved for more than two months despite follow-ups.

The available reporting did not include a public xAI response, patch, CVE identifier, or remediation timetable at the time of disclosure. That status is based on the researcher’s disclosure and contemporaneous coverage; no independently published xAI statement confirming the finding or its remediation is provided here.

What should be fixed

Adversa’s recommendations focus on the agent runtime rather than on adding more keyword filters. The most important controls are:

• Preserve provenance and taint labels. Content originating on a webpage should remain untrusted after parsing, decryption, code execution, or tool use.
• Separate data from authority. Untrusted content and values derived from it should not be able to invoke privileged tools, access private conversation context, or determine sensitive tool arguments.
• Restrict outbound traffic. Agents should apply allowlists, destination controls, and data-loss-prevention policies before sending information to a new external endpoint.
• Require meaningful consent. Requests involving private context or external transmission should require a clear user confirmation that explains what data will leave the session and where it will go.
• Apply least privilege. A summarization task should not automatically grant access to full chat history, profile metadata, code execution, or unrestricted network access.

These controls address the dangerous combination of untrusted input, private context, code execution, and action-capable tools. Model-level refusal behavior alone is not a sufficient security boundary.

How this compares with other AI-agent attacks

The Grok report is part of a wider pattern in which attackers manipulate the content an agent is asked to process, then rely on the agent’s legitimate permissions to complete the attack.

Microsoft 365 Copilot’s EchoLeak was described as a zero-click prompt-injection vulnerability in which a crafted email could enable remote, unauthenticated exfiltration of data available to the assistant. An academic case study identifies the issue as CVE-2025-32711.

Separate reporting on Microsoft Copilot Personal described the CoSnitch chain, in which a crafted link could trigger prompt execution and data exfiltration from connected applications; the researchers said Microsoft shipped patches on August 18, 2026.

Coding agents expose a similar risk through repositories rather than webpages. Adversa reported that malicious repositories could exploit trust and configuration behavior in several coding assistants, including Claude Code, Cursor CLI, Gemini CLI, and Copilot CLI, to run attacker-controlled MCP servers with potentially broad privileges. Another Adversa report described a repository-based policy bypass involving long shell-command chains and possible credential or secret theft.

The delivery mechanism differs—email, URL, document, repository, encrypted webpage, or tool integration—but the architectural lesson is consistent: an agent should not convert attacker-controlled content into permission to read confidential data or take an external action.

The broader security implication

Cryptographic Context Injection shows why agent security cannot stop at scanning the text that first enters a context window. An agent may encounter instructions after decryption, retrieval, parsing, code execution, memory access, or another tool call. If each transformation loses the origin of the data, an attacker can exploit the gap between what the system classifies as untrusted and what the runtime later treats as trusted.

For users, the practical lesson is to be cautious when asking an agent with access to private conversations or tools to process unfamiliar webpages, documents, links, or repositories. For developers, the priority is stronger: enforce trust boundaries in the runtime, limit access to sensitive context, constrain tool parameters, control network egress, and make high-impact actions visible and confirmable.

The reported Grok technique is therefore best understood not as “AES breaking” but as a warning about authority laundering. Encrypted content can hide an instruction from a filter, but only a permissive agent runtime can turn that hidden instruction into a data-theft action.