Skip to navigation

Threat reportVulnerabilityTL-2026-4575

OpenAI API 'Compaction Smuggling' Flaw Exposes Hidden GPT-5.6 Reasoning Traces

mediumPATCHED

Xint researchers demonstrated 'compaction smuggling', a technique abusing OpenAI's /responses/compact conversation-compaction feature to expose encrypted GPT-5.6 reasoning data as readable text. Replacing spaces with tabs evaded usage-policy filters, and the compaction item was relayed to weaker models (gpt-4.1, gpt-4o) that echoed it verbatim.

Key facts

IdentifiersTL-2026-4575
Also known asCompaction Smuggling, Stolen Thoughts bypass
SeverityMEDIUM
First disclosed
Affected productsOpenAI OpenAI API (Responses API /responses/compact)
Weaknesses (CWE)CWE-200, CWE-347
MITRE ATT&CK / ATLAS techniquesAML.T0024 Exfiltration via AI Inference API, AML.T0051 LLM Prompt Injection, AML.T0054 LLM Jailbreak, T1027 Obfuscated Files or Information, T1119 Automated Collection, T1190 Exploit Public-Facing Application
MotivationUNKNOWN
Target sectorstechnology, artificial-intelligence
Target regionsGlobal
Detection rules9 (1 shown free)
Sources7 cited sources

Detection coverage

As of 2026-10-27, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-4575 across Splunk SPL, Microsoft KQL and Sigma, covering 9 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: OpenAI /v1/responses/compact POST Burst via Web Proxy (Compaction Smuggling)

Flags a single source or user sending repeated POST requests to https://api.openai.com/v1/responses/compact within one hour. Compaction smuggling (TL-2026-4575, Xint, PoC compaction_smuggle.py) abuses this endpoint as a decryption oracle to turn gpt-5.6-sol encrypted_content reasoning items into readable text, and bulk use is the distillation-style signal. OpenAI deployed a server-side fix on 2026-10-23, so this is a hunting and abuse-monitoring detection. It identifies who is calling the endpoint and does not prove exploitation.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1190, T1119, T0024
  • Data sources: web_proxy, splunk_cim_web_datamodel, palo_alto_or_zscaler_proxy_logs
  • Severity: medium
  • Confidence: medium

Splunk SPL

| tstats summariesonly=false count AS compact_calls min(_time) AS firstTime max(_time) AS lastTime FROM datamodel=Web WHERE Web.url="*api.openai.com/v1/responses/compact*" AND Web.http_method=POST BY Web.src Web.user _time span=1h | where compact_calls>=5 | rename "Web.src" AS src, "Web.user" AS user | convert ctime(firstTime) ctime(lastTime) | table src user compact_calls firstTime lastTime

Microsoft KQL

CommonSecurityLog
| where TimeGenerated > ago(24h)
| where RequestMethod =~ "POST" and RequestURL contains "api.openai.com/v1/responses/compact"
| summarize CompactCalls = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated) by SourceIP, SourceUserName, DeviceVendor, bin(TimeGenerated, 1h)
| where CompactCalls >= 5
| project TimeGenerated, SourceIP, SourceUserName, DeviceVendor, CompactCalls, FirstSeen, LastSeen

Sigma

title: OpenAI Responses Compact Endpoint POST via Web Proxy
id: 3b7e1c52-9a4d-4f6e-8c21-5d0a7e9b1f34
status: experimental
description: Detects POST requests to the OpenAI /v1/responses/compact endpoint in proxy logs, the decryption-oracle step of compaction smuggling (TL-2026-4575). Apply a per-source count threshold in the SIEM.
references:
    - https://xint.io/blog/compaction-smuggling-reasoning-traces
author: Threadlinqs Team
date: 2026/10/27
tags:
    - attack.initial_access
    - attack.t1190
    - attack.collection
    - attack.t1119
    - attack.exfiltration
    - atlas.aml.t0024
logsource:
    category: proxy
detection:
    selection:
        cs-method: POST
        cs-host: api.openai.com
        c-uri|contains: /v1/responses/compact
    condition: selection
falsepositives:
    - Legitimate applications that use server-side conversation compaction
    - Approved LLM application backends calling the Responses API
level: medium

Known false positives:

  • Production applications that legitimately use the Responses API compaction feature for long conversations
  • Developers and CI jobs testing conversation compaction against api.openai.com

Tuning notes: Requires TLS inspection or a proxy that logs the full URL path. Baseline per-source compact volume for 2 weeks and raise or lower the compact_calls threshold of 5. Exclude known production service accounts and egress IPs. Escalate when the same source also appears in the cross-model relay detection (SPL-003).

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • Compaction Smuggling PoC [indicator] Execution or File Creation · unlock with TL Creds
  • store=false [indicator] Reasoning Capture Followed by Compact Call · unlock with TL Creds
  • Distillation-Scale Compaction and Cross-Model Relay Volume per API Key · unlock with TL Creds
  • Download of Compaction Smuggling PoC via git, curl, wget or PowerShell · unlock with TL Creds
  • Command-Line Invocation of OpenAI responses.compact or /v1/responses/compact · unlock with TL Creds
  • Non-Browser DNS Lookup of [indicator] or [indicator] Research Infrastructure · unlock with TL Creds
  • Compaction Request with Tab-Substitution or Reasoning-Preserving Instructions · unlock with TL Creds
  • Compaction Item Relayed to Weaker Model ([indicator] / [indicator]) After Compact Call · unlock with TL Creds

Indicators of compromise

As of 2026-10-27, Threadlinqs Intelligence tracks 9 indicators of compromise for TL-2026-4575.

Sample indicators (3 of 9)

  • Domain: stolen-thoughts[.]com
  • URL: hxxps://api[.]openai[.]com/v1/responses/compact
  • URL: hxxps://api[.]openai[.]com/v1/responses

Defanged, TLP:CLEAR. Full set of 9 indicators: unlock with TL Creds.

9 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

OpenAI confirmed the bug, paid a $6,000 bounty and deployed an undisclosed server-side fix on 2026-10-23.

Xint (research led by Tim Becker) disclosed on 2026-10-26 a bypass of OpenAI's August 2026 mitigations against theft of encrypted reasoning traces. The August protections were introduced after the 'Stolen Thoughts' research (Panfilov et al., published 2026-08-10, arXiv 2608.09867), which showed that encrypted chain-of-thought blocks returned by frontier APIs could be replayed into weaker sibling models that share the same encryption key, causing them to emit the stronger model's reasoning in plaintext. OpenAI's August mitigations blocked replaying reasoning into a different model.

Compaction smuggling circumvents that control by staying inside the originating model's ecosystem for the decryption step. The attacker first sends math or algorithm puzzles to gpt-5.6-sol with store=False and retains the returned encrypted_content reasoning item. The original task is removed from the context and the /responses/compact endpoint is called with an instructions parameter asking the compaction step to preserve the reasoning rather than summarize it, copying it word for word into the compacted item as JSON under a 'solution' key. Every space is replaced with a tab character so that usage-policy classifiers do not recognize the content. In the PoC, a 405-token reasoning item produced a 612-token compaction item.

Because compaction items are portable between models, the attacker then passes the compaction item to gpt-4.1 and gpt-4o and asks each to repeat its input exactly; each returned roughly 609 tokens of readable text, which is decoded from the JSON and has tabs restored to spaces. Xint characterizes the compaction service as a decryption oracle: any server-side step that reads a model's decrypted reasoning and follows user-supplied instructions can leak it. Xint classified the issue as CWE-200 and CWE-347. Researchers could not verify that the extracted text matched the model's original reasoning verbatim, only that multiple cheaper models reproduced identical output.

The primary risk is unauthorized distillation: reasoning traces, including failed attempts and corrections, are high-value training data for smaller models. Context in the source material notes a joint NSA/CISA/FBI advisory on industrial-scale distillation (September 2026) and OpenAI's 2026-09-30 disclosure of a disrupted distillation campaign of about 16,000 requests. No in-the-wild exploitation of compaction smuggling, CVE or CVSS score has been reported. A proof-of-concept script (compaction_smuggle.py) was published on GitHub. OpenAI confirmed the bug, applied a server-side fix requiring no developer action, and awarded a $6,000 bounty. The details of the fix are undisclosed, and severity is an analyst estimate.

MITRE ATT&CK / ATLAS techniques by tactic:

Exfiltration

AML.T0024 Exfiltration via AI Inference API

Execution

AML.T0051 LLM Prompt Injection

Defense Evasion

AML.T0054 LLM Jailbreak; T1027 Obfuscated Files or Information

Collection

T1119 Automated Collection

Initial Access

T1190 Exploit Public-Facing Application

Remediation

Patches

  • OpenAI server-side fix deployed 2026-10-23 (details undisclosed)

Immediate actions

  • No developer action required: OpenAI deployed a server-side fix on 2026-10-23
  • Monitor API usage for repeated /responses/compact calls with store=false and unusual instructions parameters
  • Review API logs for compaction items relayed to different models than the one that produced them

Workarounds

  • None published; the fix is applied by the vendor

Longer-term hardening

  • Treat any server-side step that decrypts reasoning and follows user instructions as a potential decryption oracle
  • Apply rate limiting and anomaly detection for distillation-style bulk extraction of reasoning output
  • Normalize whitespace and encoding before applying usage-policy classifiers

Affected and fixed versions

  • OpenAI — OpenAI API (Responses API /responses/compact)
    Vulnerable versions: gpt-5.6-sol reasoning items prior to 2026-10-23; gpt-4.1 and gpt-4o as decoder models
    Fixed in: Server-side fix deployed 2026-10-23

Timeline

  • 'Stolen Thoughts' research (Panfilov et al.) published, showing encrypted reasoning traces from frontier APIs can be replayed into weaker sibling models to recover plaintext reasoning
  • Stolen Thoughts attack confirmed no longer reproducible
  • OpenAI discloses a disrupted distillation campaign of about 16,000 requests, illustrating the distillation threat model
  • OpenAI deploys an undisclosed server-side fix for compaction smuggling and awards a $6,000 bounty
  • Xint publishes its technical report and PoC (locked-ioc-3) on GitHub
  • Cyber Security News, The Hacker News, CSO Online and others report the flaw

Sources cited

Previous and next in vulnerability

Drafted by the Threadlinqs research pipeline from 7 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats