KeHoSu: Keyed Homoglyph Substitution for Authenticated Text Provenance over Copy-Paste Channels
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "KeHoSu: Keyed Homoglyph Substitution for Authenticated Text Provenance over Copy-Paste Channels".
Elias: Here's the gist of the paper. In this paper we study attribution over the channel through which such text actually travels, copy-paste, which discards document metadata but keeps Unicode code points The variant chosen for each carrier letter encodes one bit of an identifier made of a platform field, a user field and a truncated authentication tag KeHoSu Mechanism We present KeHoSu, which turns the confusable characters of homoglyph attacks into a keyed attribution channel The variant chosen for each carrier letter encodes bit 0 and its Cyrillic counterpart bit 1 The identifier is encrypted and authenticated before coding For the truncated-tag construction, the payload is ct ∥ τ1:t, where ct the encrypted (p+u)-bit identifier and τ1:t the tag truncated to t bits An asymmetric mode allows anyone holding the public key to verify the platform of origin Channel Analysis We carry out an analysis of the code-point channel in terms of capacity, removability and detectability We show a joint achievable region for the three quantities The recoverable payload is at most K ≤ (1 − pe)L H2(w) bits A mark whose mixedscript detection advantage is held below a constant carries O(log L) covert bits Evaluation Results We evaluate KeHoSu over a wide range of use cases and show that the mark survived copy-paste across 18 common platforms The 50% recovery point of a 72-bit identifier lies at 167 received letters on standard English prose The mark survived copy-paste across 18 common platforms, attributing the majority of all excerpts to the correct account at 178 letters on LLM-generated stories Robustness and Invariance The symbols that the decoder collects are unchanged by any permutation of sentences, apart from a constant-size boundary layer at the two ends of the received text The decoder recomputes every index and passes the collected (index, symbol) pairs to the fountain decoder Under contentanchored placement with span clipping, the multiset of (index, symbol) pairs that the decoder collects from the interior of the retained text is a function of the selection S alone, independent of the order ψ Security and Verifiability In the asymmetric mode, any holder of the public key verifies a platform of origin, and only the platform can read the user identifier A scheme is publicly verifiable if a verifier holding only a public key pk accepts every honestly marked text and rejects, except with negligible probability We derived the capacity of the code-point channel and the minimum length of a markable text Carrier indices are keyed hashes of sentenceclipped contexts, and the extractor recovers the identifier from reordered sentences, partial quotations and locally edited text The mark survived copypaste across 18 common platforms, attributing the majority of all excerpts to the correct account at 178 letters on LLM-generated stories and 167 letters on standard English prose References
Title and authors: Nadia: So, to recap what we've discussed about KeHoSu, they are tackling the problem of attributing text across copy-paste channels where metadata is lost. They introduce this system that turns homoglyph confusion into a keyed attribution channel for tracking platforms and users.
Elias: The paper summarizes their approach by detailing how they assign one bit to the carrier letter variant—Latin versus Cyrillic—and then encrypting and authenticating an identifier that bundles platform, user, and tag information.
Priya: They also lay out the construction of the payload as ct followed by tau one to t, where ct is that encrypted identifier part and tau one to t is a truncated version of a tag used for authentication. That sounds like they're trying to make sure any fragment you have still carries some traceable data.
Nadia: Exactly. And they propose using an asymmetric mode so that anyone holding the public key can verify the platform of origin, which lets the platform read the user identifier while keeping it private from others who don't have that key.
Elias: The paper also evaluates how this system performs across different scenarios, specifically on LLM generated text and on three standard English corpora. They found that their identifier survived copy-paste through eighteen common platforms <ref:2611.08046#pg2,identifier survived copy-paste through 18>.
Priya: And they give us some concrete numbers regarding recovery, like the fifty percent recovery point of a seventy two bit identifier landing at one hundred sixty seven received letters in standard English prose. That tells us about the practical limits of what can be recovered in normal text.
Nadia: They also showed that for LLM generated stories, where people tend to copy and paste more often, the mark survived across those same eighteen platforms through one hundred seventy eight letters when attributing it to the correct account.
Elias: It seems they're demonstrating that this method has some real survival capability in common scenarios, but we still have to look at what happens when things get messy.
The paper's summary: Nadia: Now let's talk about the specific improvements they suggest over previous ideas. They focus on making the system more resilient, which is always a key area for security researchers.
Elias: They focus on two main areas: improving provenance tracking and enhancing resilience against structural edits, like reordering sentences or using partial quotations.
Priya: That makes sense because if you're trying to track something that gets chopped up, the tracking mechanism needs to be robust enough to handle that fragmentation without losing the link.
Nadia: They argue that the KeHoSu mark is invariant to any permutation of sentences, except for a constant-size boundary layer at both ends of the received text. The decoder recomputes every index and passes those pairs to a fountain decoder.
Elias: And they state that under content-anchored placement with span clipping, the set of pairs that the decoder collects from the interior of the text is just a function of the selection S alone, independent of any order psi. That addresses sentence reordering directly.
Priya: That's a big deal for robustness. It means even if someone scrambles a quote or moves sentences around, as long as they keep enough context in the middle, the core mark should still be recoverable based on what's left over.
Nadia: They also talk about increased robustness against text corruption by using a rateless fountain code to protect the payload. This is supposed to help recover even when an edit that overlaps a carrier’s context window also mis-indexes the carrier.
Elias: And they describe their recovery process as taking the K plus sixteen equations with the largest vote margins and solving them by elimination if things get corrupted in that way.
Priya: So, they're not just proposing a simple encoding scheme; they’re building a system that accounts for how real text gets damaged during copying and pasting, which is where most of these systems fall apart.
The paper's improvements: Nadia: So to wrap up the KeHoSu paper, the authors derived the capacity of this code-point channel and figured out a minimum length for a markable text. They also discussed how the carrier indices are keyed hashes of sentence-clipped contexts.
Elias: And they showed that their extractor can recover the identifier even when faced with reordered sentences, partial quotations, and locally edited text. They found that it survives copy-paste across eighteen common platforms and attributes the majority of excerpts to the correct account at one hundred seventy eight letters on LLM generated stories.
Priya: It's interesting how they put these two different results together—the capacity bounds and the practical survival rates—to give us a complete picture of what this system can actually do in practice.
Nadia: And they proved the security part too, showing that in asymmetric mode, anyone holding the public key verifies the platform of origin, and only the platform can read that user identifier. This gives investigators a way to confirm source without exposing private user data.
Elias: So what this means for us is that we now have a method to assign some form of attribution over text transfer channels, even when metadata is lost during copying. It’s about turning character substitution into a keyed channel.
Priya: For me, it suggests that if we can keep the recovery bounds low and the covert bits small, this could become a practical tool for auditing large amounts of scraped or redistributed content online.
Nadia: It certainly sounds like something that could be useful for moderation teams trying to figure out who is responsible for what they post.
Conclusion: Nadia: So we’ve been looking at KeHoSu, which is about using character variants to track where text actually comes from, even when someone just copies and pastes it across different platforms.
Elias: It turns those confusing homoglyph characters into a keyed attribution channel for the platform and the user involved.
Priya: The core idea is that each letter variant encodes one bit of an identifier that bundles the platform info, the user info, and a piece of authentication data.
Nadia: And they use an asymmetric mode so anyone with the public key can check which platform it originally came from while keeping the user stuff private.
Elias: They also showed how they handle fragmentation by making sure that even if you only have part of a quote or sentences are reordered, the mark stays relatively stable, dependent mostly on what you actually kept.
Priya: And their results show it survives copy-paste across eighteen common platforms and manages to attribute most excerpts to the right account at one hundred seventy eight letters on LLM stories.
Nadia: That’s a lot of text surviving transfer, which is pretty significant if we’re talking about tracking provenance when metadata gets stripped away.
Elias: They also gave us some numbers on the limits of recovery, like the fifty percent recovery point for a seventy two bit identifier landing at one hundred sixty seven received letters in normal English prose.
Priya: That shows us the practical floor—how much data you can realistically pull out of a message without it being completely scrambled.
Nadia: So, to wrap up, KeHoSu gives us capacity bounds for that code-point channel and tells us what the minimum length of a markable text actually needs to be.
Elias: They established that the carrier indices are keyed hashes of sentence-clipped contexts and their extractor can recover the identifier from scrambled text too.
Priya: It’s a solid framework for how we might approach tracking content integrity in these messy digital environments.
Nadia: It definitely gives us a concrete way to think about what survives when you lose the original document structure during copying.
Elias: Next week, we're looking at how those kinds of textual artifacts interact with the security risks we see with autonomous AI agents operating in real operating system environments.
Andrei Alexandru Draghici, Sediola Ruko, Briland Hitaj, Dorjan Hitaj
Sapienza University of Rome · University of Bucharest · Confidencial Inc
cs.CR, cs.LG
Submitted: 2026-11-05
Updated: 2026-11-05
Comments: 12 pages, 5 figures, 9 tables
License: http://creativecommons.org/licenses/by-nc-sa/4.0/
Importance score: 79/100
The gist: In this paper we study attribution over the channel through which such text actually travels, copy-paste…
Key concepts
- KeHoSu Mechanism
- This is the core method where homoglyph characters are used to encode information. Specifically, the variant chosen for each letter encodes a bit: one bit for the platform field and another bit for a user field, which is then encrypted and authenticated.
- Channel Analysis
- This section analyzes how much information can be reliably recovered from the text channel. It determines that while some recoverable payload exists, detecting the mark requires only a small number of covert bits relative to the total text length.
- Robustness and Invariance
- The system is designed so that removing or reordering sentences does not significantly change the collected data. The set of collected character pairs depends only on which parts of the text are kept, making it resilient to structural edits like sentence scrambling.
- Asymmetric Mode
- This security feature uses public and private keys. Anyone with the public key can verify the platform of origin, but only the platform itself can read the user identifier. This allows for secure verification without revealing sensitive user data.
Terminology
Summary
In this paper we study attribution over the channel through which such text actually travels, copy-paste, which discards document metadata but keeps Unicode code points The variant chosen for each carrier letter encodes one bit of an identifier made of a platform field, a user field and a truncated authentication tag
KeHoSu Mechanism
We present KeHoSu, which turns the confusable characters of homoglyph attacks into a keyed attribution channel The variant chosen for each carrier letter encodes bit 0 and its Cyrillic counterpart bit 1 The identifier is encrypted and authenticated before coding For the truncated-tag construction, the payload is ct ∥ τ1:t, where ct the encrypted (p+u)-bit identifier and τ1:t the tag truncated to t bits An asymmetric mode allows anyone holding the public key to verify the platform of origin
Channel Analysis
We carry out an analysis of the code-point channel in terms of capacity, removability and detectability We show a joint achievable region for the three quantities The recoverable payload is at most K ≤ (1 − pe)L H2(w) bits A mark whose mixedscript detection advantage is held below a constant carries O(log L) covert bits
Evaluation Results
We evaluate KeHoSu over a wide range of use cases and show that the mark survived copy-paste across 18 common platforms The 50% recovery point of a 72-bit identifier lies at 167 received letters on standard English prose The mark survived copy-paste across 18 common platforms, attributing the majority of all excerpts to the correct account at 178 letters on LLM-generated stories
Robustness and Invariance
The symbols that the decoder collects are unchanged by any permutation of sentences, apart from a constant-size boundary layer at the two ends of the received text The decoder recomputes every index and passes the collected (index, symbol) pairs to the fountain decoder Under contentanchored placement with span clipping, the multiset of (index, symbol) pairs that the decoder collects from the interior of the retained text is a function of the selection S alone, independent of the order ψ
Security and Verifiability
In the asymmetric mode, any holder of the public key verifies a platform of origin, and only the platform can read the user identifier A scheme is publicly verifiable if a verifier holding only a public key pk accepts every honestly marked text and rejects, except with negligible probability
Conclusion
We derived the capacity of the code-point channel and the minimum length of a markable text Carrier indices are keyed hashes of sentenceclipped contexts, and the extractor recovers the identifier from reordered sentences, partial quotations and locally edited text The mark survived copypaste across 18 common platforms, attributing the majority of all excerpts to the correct account at 178 letters on LLM-generated stories and 167 letters on standard English prose
References
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Improved provenance tracking by writing an authenticated identifier into confusable Unicode variants to trace text across copy-paste channels. This allows a moderator to know
which platform generated it and for which account
even when document metadata is discarded. -
Enhanced resilience against structural edits, such as reordering sentences or partial quotations, because the KeHoSu mark is
invariant to sentence reordering up to a constant boundary layer and depends on a partial quotation only through the retained length.
This means the system can attribute excerpts correctly even if they are fragmented or scrambled. -
Increased robustness against text corruption by employing a rateless fountain code that protects the payload, allowing for recovery even when
an edit that overlaps a carrier’s context window also mis-indexes the carrier.
This enables successful recovery under conditions wherethe decoder takes the K + 16 equations with the largest vote margins, solves them by elimination.
-
Improved detection capability against sophisticated attackers by establishing a covert security bound, showing that for monolingual cover text, a covert mark carries
K = O(log L) bits,
which is more efficient than requiring an identifier whose length isexponential in the identifier size.
This limits the information an attacker can extract from a hidden mark. -
Enhanced public verifiability through asymmetric mode, where
any holder of the public key verifies the platform of origin, and only the platform can read the user identifier.
This allows investigators to confirm a text's source without needing secret keys while keeping user identity private.
Abstract
Nowadays, large language models produce text at scale, and much of it is redistributed across platforms. A moderator who finds a suspicious comment, post or article may want to know which platform generated it and for which account. In this paper we study attribution over the channel through which such text actually travels, copy-paste, which discards document metadata but keeps Unicode code points. We present KeHoSu, which turns the confusable characters of homoglyph attacks into a keyed attribution channel: the variant chosen for each carrier letter encodes one bit of an identifier made of a platform field, a user field and a truncated authentication tag. Moreover, given that reshared text is often quoted in fragments, and the placement therefore keeps no positional state, we show that KeHoSu is invariant to sentence reordering up to a constant boundary layer and depends on a partial quotation only through the retained length. We characterize the code-point channel by its capacity, removability and detectability, and provide an achievable region that relates the three. We evaluate KeHoSu over a wide range of use cases and show that the mark survived copy-paste across 18 common platforms, attributing the majority of all excerpts to the correct account at 178 letters (about two sentences) on LLM-generated stories and 167 letters (about one sentence) on standard English prose.
Sources
- Generative Language Models and Automated Influence Operations: Emerging Threats and Potential Mitigations
- CredID: Credible Multi-Bit Watermark for Large Language Models Identification
- Provably Robust Multi-bit Watermarking for AI-generated Text
- SilverSpeak: Evading AI-Generated Text Detectors using Homoglyphs
- Publicly-Detectable Watermarking for Language Models
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data