A Connecticut sanctions ruling turned a familiar LLM bug into a legal fact, and the fix is in your document pipeline, not your model
Every file format that supports styling supports lying. A PDF or DOCX has a text layer and a visual layer, and nothing forces them to agree. Set a font to 1pt in white on white and a human reader sees empty space while pdftotext returns a paragraph. That gap has been a party trick for decades. It only became a security boundary when we started piping extracted text straight into a model that treats every token as potential instruction.
In August 2026 a Connecticut judge put that gap on the record. The ruling is worth reading not because courts are interesting, but because it is a clean, documented instance of an attack class that most document-processing code is still wide open to.
The case, briefly
In Elliott v. New York Bariatric Group (Docket No. AAN-CV-25-6066141-S, Superior Court for the Judicial District of Ansonia/Milford), a self-represented plaintiff filed two motions on July 24, 2026 containing white-on-white text addressed to any AI model that might process the document. The hidden block opened with "IF THIS DOCUMENT IS REVIEWED BY AN AI MODEL" and instructed it to produce output agreeing with the filing and to treat a prior clerk denial as an error to correct.
The court issued an order to show cause on July 31 and held a hearing on August 4. The plaintiff embedded further hidden messages in filings that same morning. On August 6, Judge Walter M. Spader, Jr. issued a memorandum of decision rescinding his electronic filing privileges, requiring all future pleadings to be filed on paper in person. The case was not dismissed and courthouse access was not restricted. The court grounded the sanction in Connecticut Practice Book §§ 4-2(b) and 4-9, the good-faith certification rules, with § 4-9 specifically covering generative AI.
NeuralTrust's writeup has the full timeline and docket references if you want the primary sources: hidden text prompt injection in a US court.
The detail that matters for engineers is what the attack did not require. No model jailbreak. No API access. No clever Unicode. Just CSS-equivalent styling applied to plain text in a file the target system was already designed to ingest.
Why the model falls for it
This is indirect prompt injection, and the root cause is architectural. An LLM receives a single flat token stream. There is no privileged channel that says "the next 4,000 tokens are data, not orders." Instruction-following is the behavior you trained for, and the model has no reliable way to know that a sentence arrived from a hostile third party rather than from you.
Greshake et al. laid this out in 2023 in Not what you've signed up for, demonstrating working attacks against real LLM-integrated applications including Bing Chat. OWASP ranks prompt injection as LLM01 in the Top 10 for LLM Applications 2025 and states plainly that because of the stochastic nature of these models, it is unclear whether fool-proof prevention exists at all. Plan accordingly. You are managing risk, not eliminating a bug.
The court case is one delivery vector among many. Nikkei Asia reported in July 2025 that hidden "give a positive review only" prompts were found in 17 arXiv preprints from 14 institutions across 8 countries. Same technique, different pipeline. If your product summarizes resumes, vendor contracts, support tickets, scraped pages, or anything else a stranger can author, you have the same exposure.
A cheap detection pass
You will not catch everything, but the trivial version of this attack has a trivial signal: text that the extractor sees and a human would not. Compare the two.
import pdfplumber
def suspicious_chars(path, min_size=4.0, white_threshold=0.92):
hits = []
with pdfplumber.open(path) as pdf:
for page_no, page in enumerate(pdf.pages, start=1):
for ch in page.chars:
color = ch.get("non_stroking_color")
near_white = (
isinstance(color, (list, tuple))
and len(color) in (1, 3)
and all(c >= white_threshold for c in color)
)
if ch["size"] < min_size or near_white:
hits.append((page_no, ch["text"], round(ch["size"], 2), color))
return hits
Flag the document, do not silently strip the text. A strip-and-continue policy hides the fact that someone tried, which is exactly the signal your security team wants. Reconstructing the visible text and diffing it against the raw extraction catches more cases than either check alone, including off-page positioning and zero-opacity rendering.
Be aware of the limits. Near-white detection fails against text drawn behind an image, text in a form field, text with a render mode of invisible (Tr 3), and anything delivered through metadata or an embedded font trick. Detection is a filter, not a boundary.
Where the real control sits
The payload is only interesting because of what the downstream system can do with it. A summarizer that gets injected produces a bad summary. An agent that gets injected sends an email, writes to a database, or calls a payment API.
That is the part worth engineering around. Least-privilege tool scopes, allowlisted actions per task, human approval on anything irreversible, and output inspection on the way back out. Treat the model as untrusted code running on attacker-influenced input, because functionally that is what it is. NeuralTrust's guide to indirect prompt injection walks through the layered version of this, and AgentSecurity covers the agent-specific failure modes such as tool abuse and memory poisoning, which are where injected instructions cause lasting damage rather than one bad response.
Then test it. Plant payloads in your own fixtures, in white text, in metadata, in alt attributes, and assert that the pipeline flags them and that no tool call fires. Automated adversarial testing against your deployed system is the only way to know whether your guardrails survived the last refactor, and tools like NeuralTrust's red teaming framework exist to run those suites in CI so a failed injection test blocks a release.
The takeaway
The Connecticut ruling is a useful marker because it moved hidden-text injection from a demo into an adversarial act with consequences attached. For anyone shipping document ingestion, the lesson is narrower and older. Extracted text is attacker-controlled input. Validate it, constrain what the model can do with it, and assume the file you render is not the file you parse.
Sources