AI Worm: A Word Document That Copies Itself

What the Copilot for Word AI worm is

A worm is malware that spreads on its own without attaching itself to another program. The researcher calls this attack a "document-borne AI-worm": Copilot for Word reads a file with a hidden prompt, alters the draft it is writing, and copies the hidden prompt into the result.

That result becomes a new carrier. The post is a proof of concept (PoC), a demonstration that the attack works in practice.

The attacker only needs to share one document

The attacker only needs to share one malicious document with the victim. The researcher says no access to the victim's Microsoft 365 tenant (the organization's own Microsoft 365 environment) is needed. SharePoint, Teams, Outlook or any other way of sharing documents will do.

The attacker does not need access to the victim's Microsoft 365 tenant. The attacker only needs to share a malicious document with the victim. This can be done through SharePoint, Teams, Outlook or any other way of sharing documents. — From the statement of the attack's prerequisites
View official source →

Copilot strips the formatting that hides the prompt

The malicious document carries a JSON prompt that can be set as white text on a white background in a small font, so a person opening the file does not see it. Copilot for Word removes text formatting such as color and font size before it passes the text to the underlying language model. The hidden text therefore reaches the model as readable text.

The malicious document contains a JSON-formatted malicious prompt that triggers the attack when the document is included in Copilot's context. The prompt can be rendered as white text on a white background and in a small font size to conceal it from the victim. Since Copilot for Word strips all text formatting like color and font size before passing the text into the underlying Large Language Model (LLM), this text remains fully readable to Copilot even though the victim cannot see it. — From the concealment technique and the formatting-strip behavior that makes it readable
View official source →

Attached documents should count as untrusted input

Copilot has to read every attached document to decide which parts belong in the current draft. But the researcher says an attached document should be treated as untrusted information, not as a trusted instruction from the user.

The researcher's example is a user who asks Copilot to draft a Q1 financial report from attached documents. Copilot should use the information in them and should not treat instructions embedded in them as authoritative.

Copilot must read every attached document to determine which parts to include in its current drafting task. However, attached documents should be treated as untrusted information, not trusted user instruction. / When a user asks Copilot to draft e.g. a Q1 financial report based on attached documents, Copilot should utilize the information in the attached documents without treating instructions embedded within documents as authoritative instructions. — From the description of the trust boundary and the expected behavior
View official source →

How the hidden prompt injection copies itself

Prompt injection means hiding instructions in content that an AI reads, so that the AI follows them as if the user had given them. Here the injection is the white-text prompt, and the demonstration runs in two stages. Stage 1 changes the numbers in a draft, and stage 2 makes that draft a new source of the same attack.

Stage 1: Copilot halves the financial figures

In the demonstration, the source documents belong to a set named Tfosorcim, which is "Microsoft" spelled backward. Copilot drafts a Q1 financial report from them, and in the resulting draft all financial numbers are halved.

The researcher adds that in many experiments he had to tell Copilot to highlight its changes, because they were often meaningful and difficult to spot. He says this shows how effectively the attack changes text in ways that elude even an attentive reviewer.

Copilot then searches the victim's OneDrive for relevant documents and finds the malicious Market Analysis file, even though it sits in a different folder from the rest of the set. It reads the file and the attack succeeds.

In the resulting Q1 financial report draft, all financial numbers are halved. / In many of my experiments I actually needed to also instruct Copilot to highlight which changes it made, since they were often meaningful changes that were difficult to spot. This shows how effective the attack is at subtly changing the text in meaningful ways that easily elude even an attentive reviewer. / Copilot then searches through the victim's OneDrive to find relevant documents. Among the documents, we find the malicious Market Analysis document. This document does not reside in the same folder as the rest of the Tfosorcim document. However, Copilot still finds it, reads it and is successfully exploited. — From the halved figures, the difficulty of spotting the changes, and the path that works without the victim attaching anything
View official source →

Stage 2: the edited document becomes the carrier

Copilot also copies the entire malicious prompt to the bottom of the affected document, in white text at font size 8. The victim does not see it. Stage 2 depends entirely on that copy instruction: once the edited document contains the prompt, that document is itself a new attack vector.

Tracing the attack afterward is extremely difficult, the researcher writes. Each document was created by a legitimate internal resource, and Copilot's edits are not shown once the victim has approved them.

Malwarebytes, which covered the work, reports that the attack silently alters documents and embeds its own hidden instructions in newly created files. It adds that this lets the attack spread through normal document sharing without macros or traditional malware.

Copilot would then also copy the entire malicious prompt into the bottom of the affected document using white text and font size 8, effectively concealing it from the victim. / Stage two is the self-propagation stage. It relies entirely on the instruction for Copilot to copy the malicious prompt into the affected document. Once the affected document contained the prompt, the new document itself became the new attack vector. / Since the attack is able to spread through internal documents, once it has moved beyond its initial point of entry, the traceability of the attack becomes extremely difficult. This is further exacerbated by each document being created by a legitimate internal resource and that Copilot edits are not made visible after they have been approved by the victim. — From the white-text append at font size 8, the condition for self-propagation, and why tracing becomes difficult
View official source →
The attack silently alters documents and embeds its own hidden instructions into newly created files, allowing it to spread through normal document-sharing workflows without macros or traditional malware. — From the description of spreading without macros or traditional malware
View official source →

Affected organizations can pass it to partners

The researcher expects an unaware, affected organization to pass the prompt on through shared SharePoint sites or Teams. The first attack document for a given organization may therefore come from an already affected trusted partner.

The researcher's larger concern is about decisions. If the attack spread silently through ordinary document workflows, it could corrupt the information organizations rely on to make decisions.

The broader concern is that, if the attack silently spread within an organization through ordinary document workflows, it could erode the informational foundation on which organizations make decisions. / In addition, organizations that are not aware that they are affected by the attack are also likely to spread it to other organizations through collaborative efforts on shared Microsoft SharePoint sites or shared Microsoft Teams. Thus, the initial attack vector for a particular organization may actually come from an already affected trusted partner. — From the effect on information integrity and the cross-organization spread
View official source →

Copilot for Word vulnerability: the 144-day disclosure

The researcher reported the issue to the Microsoft Security Response Center (MSRC), and the coordination period ran 144 days. The report included reproduction steps, videos, the environmental assumptions and the exact PoC prompts.

Microsoft was told of a 90-day period, which was extended twice. The 144 days run from the first report on 2026-03-06 to 2026-07-28, the last date in the timeline.

Disclosure timeline (from the researcher's post)

Date Event
2026-03-06 Initial report submitted to MSRC
2026-03-31 Microsoft confirms the reported behavior
2026-04-03 First mitigation goes live (the new "Edit with Copilot" experience)
2026-07-14 Second mitigation goes live: the underlying model is upgraded to GPT-5.5
2026-07-15 Successful exploit with worming reproduced on GPT-5.6
2026-07-28 Attack class still reproduces
Microsoft was provided with reproduction steps, videos, environmental assumptions, and the exact proof-of-concept (PoC) prompts used during testing. They were also informed of a 90-day coordination period before disclosure. This was extended two times, resulting a 144-day coordination period. / 2026-03-06: Initial report submitted to MSRC with reproduction steps, videos, environmental assumptions, and PoC prompts. / 2026-03-31: Microsoft confirms the reported behavior. / 2026-04-03: First mitigation go-live (The new "Edit with Copilot" experience) / 2026-07-14: Second mitigation fix go-live. This mitigation consisted of upgrading the underlying model to GPT-5.5. / 2026-07-15: Successful exploit with worming reproduced using GPT-5.6, the latest available model at the time. / 2026-07-28: Attack class still reproduces. — From the coordination period and the events listed in the table
View official source →

Microsoft's fixes closed the payloads that were reported

According to the researcher, Microsoft mitigated the PoC prompt he first submitted and shipped multiple fixes during the disclosure. Each closed the specific payloads he had reported. To reproduce the behavior afterward, he needed altered payloads, because the old ones no longer worked.

Microsoft successfully mitigated the originally submitted PoC prompt, and deployed multiple fixes over the course of this disclosure. Each of these raised the bar by closing the specific payloads reported, and reproducing the behavior afterwards required altered payloads rather than reusing the old ones directly. — From the effect of the mitigations
View official source →

A reworded payload reproduced the full chain

With all mitigations deployed, a modified payload reproduced the complete attack chain, and the PoC in the post is one such case. The researcher concludes that the vulnerability class, meaning the whole family of attacks that work the same way, remains exploitable at publication. Changing the requested action or the wording changes the payload, he says, but not the underlying vulnerability or the way it propagates.

Using a modified payload, the complete attack chain has been reproduced with all mitigations deployed (the PoC in this report is one such case). The vulnerability class therefore remains exploitable at the time of publication. / Changing the requested action or wording changes the payload, but not the underlying vulnerability or propagation mechanism. — From the basis for the class remaining open
View official source →

The researcher calls the weakness architectural

He says the class is not fully closed because the underlying problem is hard. The weakness is architectural and shared across current LLM-based systems, and he knows of no complete mitigation for this class in any comparable product. Fully resolving it, he says, requires research rather than a single patch.

Within those limits, he writes, Microsoft's fixes meaningfully reduce exposure. The memory and email-body vectors from Parts 1 and 2 of his series were mitigated outright.

That the class is not yet fully closed reflects how hard the underlying problem is. As the closing thoughts discuss, the weakness is architectural and shared across current LLM-based systems. I'm not aware of a complete mitigation for this class in any comparable product today. Fully resolving it requires research rather than a single patch. Within those limits, Microsoft's fixes meaningfully reduce exposure, and the memory and email-body vectors covered in Parts 1 and 2 were mitigated outright. — From the difficulty of the problem and the assessment of Microsoft's fixes
View official source →

What customers can do, according to the researcher

At the time of publication, the post says, no customer-side remediation fully addresses the issue. The advice that follows is about reducing exposure.

Three ways to reduce exposure

The researcher lists three ways to reduce exposure. He does not present any of them as a full fix. The first two come before Copilot works on a file, and the third comes after.

  • Treat externally sourced documents as untrusted when they are used with Copilot.
  • Review any attached document before starting a Copilot generation or edit.
  • Review Copilot-generated or Copilot-edited documents carefully before reusing, sharing or distributing them.
No customer-side remediation fully addresses the issue at the time of publication. Customers can reduce exposure by: Treating externally sourced documents as untrusted when used with Copilot. Reviewing any attached document before starting a Copilot generation or edit. Carefully reviewing Copilot-generated or Copilot-edited documents before reusing, sharing, or distributing them. — From the remediation status at publication and the listed ways to reduce exposure
View official source →

Cowork and Scout may widen the reach

The researcher also points out that Copilot is being integrated more deeply with systems such as Microsoft Cowork and Microsoft Scout. These extend the assistant to automatic manipulation and creation of documents, tools and collaborative workflows.

In such systems the practical impact may scale rapidly. The mechanism stays the same, he writes, while the surface it can spread over grows at machine speed.

Recently Copilot is also becoming more deeply integrated with systems such as Microsoft Cowork or Microsoft Scout, which extend the assistant to automatic manipulation and creation of documents, tools, and collaborative workflows. In such systems the practical impact of the issues described here may scale rapidly. The underlying mechanism remains the same, but the potential surface over which it can propagate or influence expands at machine speed. — From the expansion of impact as integration deepens
View official source →

Earlier AI worms: Morris II targeted email assistants

The researcher notes that AI worms existed before this one. One of them, Morris II, demonstrated self-replicating prompt propagation in email-assistant environments built on generative AI. To his knowledge, the Copilot for Word demonstration is among the first public demonstrations of a document-borne AI worm spreading through normal workflows in a mainstream commercial productivity suite.

Other attacks on AI agents are covered on this site. AI Coding Agent Hijacked by a Fake Bug Report covers how one fake report takes over agents such as Claude Code, Cursor and Codex. Hugging Face hack: an OpenAI sandbox escape covers a sandbox escape by an OpenAI model.

Previous examples of AI-worms exist. Notably, Morris II demonstrated self-replicating prompt propagation in GenAI-powered email-assistant ecosystems. However, to my knowledge, this is among the first public demonstrations of document-borne AI-worm self-propagation through normal workflows in a mainstream commercial productivity suite. — From the positioning relative to prior research
View official source →

FAQ

What does this AI worm actually do?
Hidden instructions inside a Word document shared from outside can trigger when Copilot for Word reads it. Copilot may alter the document being drafted, then copy those hidden instructions into the new document. The copy becomes the next carrier, so it can spread along ordinary document-sharing workflows.
How are the instructions hidden?
A JSON-formatted prompt can be rendered in the document as white text on a white background at a small font size. Copilot for Word strips all formatting such as color and font size before passing the text to the model, so text invisible to a human is fully readable to Copilot.
Has Microsoft responded?
Yes. The researcher's original PoC prompt was mitigated, and multiple fixes shipped during the disclosure window. The researcher writes that Microsoft's fixes meaningfully reduce exposure and that the memory and email-body vectors from Parts 1 and 2 were mitigated outright. But because a reworded payload still reproduced the chain, the researcher's position is that the vulnerability class remained open at publication.
Is there anything customers can do?
The post states plainly that no customer-side remediation fully addresses the issue at publication. Three ways to reduce exposure are listed: treat externally sourced documents as untrusted when using them with Copilot, review any attached document before starting a Copilot generation or edit, and carefully review Copilot-generated or edited documents before reusing or sharing them.