Text Steganography Using Devanagari Script Features
Steganography is the practice of hiding information inside ordinary data so that the very existence of the hidden message is concealed. While many early techniques relied on image or audio carriers, text steganography has gained attention because text is ubiquitous and easy to distribute. The Devanagari scriptused for Hindi, Marathi, Nepali, Sanskrit, and several other Indian languagesoffers a rich set of orthographic features that can be exploited for covert communication. This page explains the most practical Devanagaribased steganographic methods, discusses their security considerations, and provides sample code snippets.
Why Devanagari?
- Complex orthography: Consonant clusters, vowel signs (matras), and diacritic marks provide multiple visual variants of the same logical character.
- Zerowidth joiners: Unicode defines
U+200C(ZERO WIDTH NONJOINER) andU+200D(ZERO WIDTH JOINER) to control ligature formation, which are invisible in rendering. - Optional Nukta and Virama: The same phoneme can be written with or without the nukta (dot) or virama (halant) depending on style, dialect, or typographic preferences.
- Multiple code points for the same glyph: For instance,
(U+090F) vs(U+090F U+0902) where the chandrabindu may be omitted without changing meaning in casual writing.
Core Techniques
1. ZeroWidth Characters (ZWC)
Unicode contains several zerowidth characters that are completely invisible when displayed. By mapping binary data to a selection of these characters, we can embed bits without altering the visible text. The most common set includes:
| Character | Code Point | Binary representation |
|---|---|---|
| Zero Width Space | U+200B | 00 |
| Zero Width NonJoiner | U+200C | 01 |
| Zero Width Joiner | U+200D | 10 |
| Word Joiner | U+2060 | 11 |
Implementation steps:
- Convert the secret message to a binary string.
- Split the binary string into 2bit groups.
- Replace each group with the corresponding ZWC.
- Insert the resulting ZWC sequence into a natural place in the Devanagari textcommonly after a punctuation mark, line break, or after a consonant with a halant.
Original: Encoded :
2. Matra Position Variants
Devanagari vowel signs (matras) can be placed before, after, above, or below the base consonant. Certain matras (e.g., , , ) have two possible Unicode sequences:
- Precomposed character (e.g.,
U+0906) - Base consonant + matra (e.g.,
+U+0905 U+093E)
Choosing one representation over the other does not affect rendering but can encode a single bit. For longer messages, the same principle can be extended to use multiple matras.
Word: ""OptionA: U+092A U+093E U+0910 (precomposed) bit 0 OptionB: U+092A U+0902 U+093E (base + anusvara + matra) bit 1
3. Nukta / Conjunct Alternatives
The nukta (dot) modifies a consonant to represent sounds borrowed from Persian, Arabic, or English. Some phonemes can be written with or without the nukta depending on regional spelling conventions. For example:
(U+0915 U+093C) vs+(U+0915 U+200C U+093C)- Both render as qa but the presence of a ZWNJ changes the code point sequence.
Using the presence (1) or absence (0) of a ZWNJ before the nukta provides another binary channel.
4. Optional Halant (Virama) Placement
In Devanagari, a halant (U+094D) suppresses the inherent vowel, creating conjunct consonants. Certain consonant clusters can be expressed in two ways:
- Explicit halant followed by the next consonant.
- Using a precomposed conjunct glyph (available in some fonts).
Choosing between the two encodes a bit. Example with the cluster :
Explicit: (U+0915 U+094D U+200D U+0937) bit 0 Conjunct : (U+0915 U+094D U+0937) bit 1
Combining Techniques
To increase capacity, a hybrid approach can be used. A typical encoding pipeline:
- Map the secret binary string to a stream of symbols using a mixedradix scheme: ZWC (2 bits) + Matra choice (1 bit) + Nukta variant (1 bit).
- Traverse the cover text; whenever a suitable insertion point is found (e.g., after a vowel sign or before a conjunct), embed the next symbol.
- If the cover text runs out of suitable positions, pad with innocuous filler words that also contain the required orthographic features.
This method balances payload size with imperceptibilitylarger payloads require more varied text, but the natural diversity of Devanagari reduces suspicion.
Security Considerations
- Statistical detection: Repeated use of a particular zerowidth character can be spotted with frequency analysis. Randomize the mapping or use a pseudorandom sequence keyed by a shared secret.
- Normalization attacks: Unicode Normalization Form C (NFC) or Form D (NFD) can change the underlying code points, destroying hidden data. Send the message in a format that preserves raw code points (e.g., plain .txt without automatic normalization) or apply a reversible normalizationresistant encoding.
- Font dependency: Some fonts may render ZWJ/ZWJ sequences as visible glyphs (e.g., ligature formation). Choose widely supported Unicode fonts like Noto Sans Devanagari or ensure the receiver uses the same rendering environment.
- Steganalysis tools: Modern text analysis frameworks can flag uncommon Unicode sequences. To mitigate, blend hidden characters with normal typographic errors or use a low embedding rate (e.g., 1 bit per 10 words).
Sample JavaScript Encoder/Decoder
The following minimal code demonstrates embedding using zerowidth characters. It can be extended to include matra and nukta variants.
// Simple ZWC steganography for Devanagari textconst zwcMap = { '00': '\u200B', // Zero Width Space '01': '\u200C', // Zero Width NonJoiner '10': '\u200D', // Zero Width Joiner '11': '\u2060' // Word Joiner};const revZwcMap = Object.fromEntries( Object.entries(zwcMap).map(([bits, char]) => [char, bits]));function textToBinary(text) { // UTF8 encoding then binary string const encoder = new TextEncoder(); return Array.from(encoder.encode(text)) .map(b => b.toString(2).padStart(8, '0')) .join('');}function binaryToZwc(bin) { let zwc = ''; for (let i = 0; i < bin.length; i += 2) { const bits = bin.substr(i, 2); zwc += zwcMap[bits]; } return zwc;}function embed(secret, cover) { const bin = textToBinary(secret); const zwcSeq = binaryToZwc(bin); // Insert after every punctuation or at the end if none const punct = /[!?]/g; let idx = 0, result = ''; for (let i = 0; i < cover.length; i++) { result += cover[i]; if (punct.test(cover[i]) && idx < zwcSeq.length) { result += zwcSeq[idx++]; } } // Append remaining ZWCs result += zwcSeq.slice(idx); return result;}function extract(stego) { const zwcChars = Object.values(zwcMap).join(''); const filtered = Array.from(stego).filter(ch => zwcChars.includes(ch)).join(''); let bits = ''; for (const ch of filtered) { bits += revZwcMap[ch]; } // Convert bits to bytes const bytes = []; for (let i = 0; i < bits.length; i += 8) { const byte = bits.substr(i, 8); if (byte.length === 8) bytes.push(parseInt(byte, 2)); } const decoder = new TextDecoder(); return decoder.decode(new Uint8Array(bytes));}// Example usage:const cover = ' ';const secret = 'HideMe';const stego = embed(secret, cover);console.log('Stego text:', stego);console.log('Recovered:', extract(stego));Practical Tips for RealWorld Use
- Choose a natural cover text: News articles, literary excerpts, or socialmedia posts written in Hindi provide many insertion points.
- Limit embedding density: Aim for 5bits per sentence to stay below typical statistical thresholds.
- Use a secret key: Shuffle the order of embedding positions with a PRNG seeded by a shared passphrase. The same key is required for extraction.
- Test crossplatform: Send the stego text through email, messaging apps, and copypaste to verify that hidden characters survive the pipeline.
Conclusion
Devanagaris inherent visual flexibility, combined with Unicodes invisible control characters, offers a fertile ground for text steganography. By exploiting zerowidth characters, matra alternatives, nukta variants, and optional halant representations, it is possible to embed a meaningful amount of secret data while keeping the carrier text indistinguishable from ordinary Hindi prose. Careful attention to normalization, font handling, and statistical camouflage is essential for a robust implementation. With the example code above as a starting point, developers can build custom tools tailored to specific threat models and communication channels.
Text Steganography Using Devanagari Script Features and Reference File Download Link
Text Steganography Using Malayalam Unicode and Reference File Download Link
Handwritten Devanagari Script Recognition and Reference File Download Link