KeHoSu: Keyed Homoglyph Substitution for Authenticated Text Provenance over Copy-Paste Channels

summary

The gist

In this paper we study attribution over the channel through which such text actually travels, copy-paste…

In short

KeHoSu is a system that uses subtle changes in characters (homoglyphs) to embed an encrypted identifier into text. This allows tracking where text came from, even when copied or pasted across different platforms, while discarding original document metadata. It provides verifiable provenance and resilience against common text manipulations.

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 used across episodes

This episode discusses

The paper

KeHoSu: Keyed Homoglyph Substitution for Authenticated Text Provenance over Copy-Paste Channels · Read on arXiv

Andrei Alexandru Draghici, Sediola Ruko, Briland Hitaj, Dorjan Hitaj

Sapienza University of Rome · University of Bucharest · Confidencial Inc

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.

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.

More episodes

← Home