RRC स्टेग्नोग्राफी

रोटेशन रेंज-कोडिंग (RRC) स्टेग्नोग्राफी — एक कुशल और प्रमाणित रूप से सुरक्षित भाषाई स्टेग्नोग्राफिक विधि जो बड़े भाषा मॉडल द्वारा उत्पन्न प्राकृतिक-भाषा पाठ में गुप्त संदेशों को एम्बेड करती है।

पेपर: Efficient Provably Secure Linguistic Steganography via Range Coding (ACL 2026)

यह कैसे काम करता है

चरण	विवरण
एम्बेड (एल्गोरिद्म 3)	गुप्त संदेश को दशमलव मान में परिवर्तित करें और LM की प्रायिकता वितरण तथा PRNG-जनित ऑफ़सेट द्वारा निर्देशित एक सिकुड़ते अंतराल के भीतर इसे पुनरावृत्त रूप से घुमाएँ। प्रत्येक रोटेशन चरण एक टोकन उत्पन्न करता है।
निकालें (एल्गोरिद्म 4)	अंतराल सीमाओं को पुनः प्राप्त करने के लिए स्टेगोटेक्स्ट पर LM को पुनः चलाएँ, फिर मूल दशमलव मान पर विपरीत-घुमाएँ और इसे बाइनराइज़ करें।

रोटेशन तंत्र वनीला रेंज-कोडिंग स्टेग्नोग्राफी की दो समस्याओं को हल करता है:

1. प्रायिकता-वितरण संरक्षण — घुमाया गया गुप्त मान प्रत्येक अंतराल के भीतर समान रूप से वितरित होता है, इसलिए टोकन चयन मूल LM वितरण का अनुसरण करता है।
2. नई यादृच्छिकता — प्रत्येक चरण में एक नया PRNG ऑफ़सेट यादृच्छिकता के पुनः उपयोग को रोकता है।

रिपॉज़िटरी संरचना

.
├── rrc_core.py        # Algorithms 3 and 4, shared by every entry point
├── RRC_embed.py       # Embedding CLI
├── RRC_extract.py     # Extraction CLI (reports recovery accuracy)
├── test_roundtrip.py  # Round-trip test across several message lengths
├── fastest_embed.py   # Embedding-speed benchmark
├── 0.Prompts.tsv      # 1000 prompts (first ~10 words of C4 sequences)
└── requirements.txt

एनकोडर और डिकोडर लूप की अलग-अलग प्रतियाँ रखने के बजाय rrc_core.py साझा करते हैं। दोनों पक्षों को बिट-दर-बिट सहमत होना चाहिए, और दो स्वतंत्र रूप से अनुरक्षित प्रतियों के बीच विचलन केवल विफल राउंड ट्रिप के रूप में सामने आता है, निरीक्षण पर कभी नहीं।

आवश्यकताएँ

• Python >= 3.10
• PyTorch >= 2.0
• Transformers >= 4.35 (5.x तक परीक्षित)

pip install -r requirements.txt

त्वरित शुरुआत

1. शुद्धता सत्यापित करें

python test_roundtrip.py                                  # GPT-2, 32/128/512 bits
python test_roundtrip.py --model meta-llama/Llama-2-7b-hf

2. एम्बेड करें

python RRC_embed.py \
    --language_model meta-llama/Llama-2-7b-hf \
    --bit_length 128 --key 42 --top_k -1

3. निकालें

python RRC_extract.py \
    --language_model meta-llama/Llama-2-7b-hf \
    --bit_length 128 --key 42 \
    --input_file 1.RC_decimal_Llama-2-7b-hf_bit128.tsv

एनकोडर उस गुप्त संदेश को रिकॉर्ड करता है जिसे उसने एम्बेड किया और उन टोकन आईडी को जो इसे ले गए, इसलिए निष्कर्षण एक रिकवरी दर रिपोर्ट करता है। दो रिसीवर मॉडल स्कोर किए जाते हैं:

• ids — रिसीवर को टोकन अनुक्रम दिया जाता है। यह कोडिंग योजना को अलग करता है; 100% से नीचे कुछ भी एक संख्यात्मक या तार्किक दोष है।
• text — रिसीवर को डीटोकनाइज़्ड स्ट्रिंग दी जाती है और इसे फिर से टोकनाइज़ करता है, जैसा कि एक टेक्स्ट चैनल की आवश्यकता होती है। पुनः-टोकनाइज़ेशन हमेशा प्रेषक के विभाजन को पुनः उत्पन्न नहीं करता, इसलिए यह एक निचली सीमा है; दोनों मापों के बीच का अंतर कोडिंग योजना के बजाय टोकनाइज़ेशन अस्पष्टता को मापता है। Llama-2-7b पर 128 बिट्स पर: ids के लिए 100%, text के लिए ~91%।

महत्वपूर्ण: प्रेषक और रिसीवर को भाषा मॉडल, कुंजी, बिट लंबाई और top-k सेटिंग साझा करनी चाहिए, और समान हार्डवेयर और लाइब्रेरी संस्करण भी चलाने चाहिए। संख्यात्मक आवश्यकताएँ देखें।

CLI आर्गुमेंट्स

RRC_embed.py और RRC_extract.py द्वारा साझा:

आर्गुमेंट	डिफ़ॉल्ट	विवरण
--language_model	meta-llama/Llama-3.1-8B	HuggingFace मॉडल आईडी
--bit_length	128	बिट्स में गुप्त संदेश की लंबाई
--top_k	-1	Top-k ट्रंकेशन; -1 = पूरी शब्दावली
--key	42	सममित कुंजी K (PRNG सीड)
--precision_margin	40	2**bit_length को जितने दशमलव अंक चाहिए उससे अधिक अंक
--max_ctx_len	3900	KV-कैश विंडो
--device	auto	cuda या cpu

RRC_embed.py --prompts, --output, --limit, --seed, --max_tokens, --resume, --no_verify, और प्रॉम्प्ट सेट को प्रक्रियाओं में शार्ड करने के लिए --part / --part_max भी लेता है (--part_max 3 के साथ --part 0,1,2, प्रति GPU एक)।

RRC_extract.py --input_file, --mode {ids,text,both}, --limit और --verbose भी लेता है।

संख्यात्मक आवश्यकताएँ

RRC चौड़ाई 2**l के एक अंतराल को चौड़ाई ~1 तक संकुचित करता है, इसलिए पुनः प्राप्त मान 2**l के कारक द्वारा सापेक्ष त्रुटि के प्रति संवेदनशील होता है: 128 बिट्स पर श्रृंखला में कहीं भी 1e-16 का सापेक्ष विक्षोभ परिणाम को 0.5 की सहनशीलता के विरुद्ध ~1e22 तक विस्थापित कर देता है। निष्कर्षण शालीनता से क्षीण नहीं होता — यह या तो संदेश लौटाता है या असंबंधित बिट्स लौटाता है। Llama-2-7b पर मापा गया:

सेटिंग	प्रायिकताओं का सापेक्ष विक्षोभ	निष्कर्षण
समान batch-1 डिकोड दोहराना	0 (बिटवाइज़ समान)	काम करता है
batch 2 / 8 / 16 पर समान पंक्ति	~1e-2	विफल
प्रॉम्प्ट को बाएँ-पैड करना	~1e-2	विफल
इंक्रीमेंटल डिकोडिंग के बजाय एक teacher-forced पास	~4e-3	विफल

दो परिणाम कार्यान्वयन को आकार देते हैं। बैचिंग अनुपलब्ध है, इसलिए अनुक्रमों को एक बार में एक संसाधित किया जाता है। और रिसीवर स्टेगोटेक्स्ट को एक ही फ़ॉरवर्ड पास में स्कोर करने के बजाय प्रेषक की इंक्रीमेंटल डिकोडिंग को चरण-दर-चरण दोहराता है, भले ही उसके पास हर टोकन पहले से हो। दोनों शॉर्टकट ~9x तेज़ मापे जाते हैं और न तो प्रायिकताओं को संरक्षित करते हैं।

लॉजिट्स के बाद सब कुछ float64 है और CPU और GPU पर बिटवाइज़ समान सीमाएँ उत्पन्न करता है, इसलिए फ़ॉरवर्ड पास ही एकमात्र चरण है जो स्टेगोटेक्स्ट को उसके हार्डवेयर से बाँधता है।

दशमलव परिशुद्धता

परिशुद्धता संदेश की लंबाई से ceil(bit_length * log10(2)) + margin के रूप में निकाली जाती है और कुछ और चलने से पहले सेट की जाती है। यह संदेश के साथ बढ़ती है: 2**256 को 78 अंक चाहिए और 2**8192 को 2466।

उस सीमा से नीचे की परिशुद्धता सफाई से विफल नहीं होती। गुप्त मान के निम्न-क्रम अंक गोल कर दिए जाते हैं, अंतराल कुछ टोकन के भीतर ढह जाता है और समाप्ति परीक्षण जल्दी सक्रिय हो जाता है, इसलिए एक रन पूरा हो सकता है और ऐसे आँकड़े रिपोर्ट कर सकता है जो अंकगणितीय रूप से अप्राप्य हैं। संदेश की लंबाई की परवाह किए बिना परिशुद्धता को 50 अंकों पर बनाए रखने पर यह मिलता है:

बिट्स	50 अंकों पर उपयोग	पूर्ण होने वाले नमूने	व्युत्पन्न परिशुद्धता के साथ
256	157.05%	8/20	100.17%
512	299.67%	9/20	102.48%
1024	660.91%	7/10	102.58%
2048	1046.40%	1/5	98.18%
4096	2483.92%	3/3, कोई त्रुटि नहीं उठाई गई	100.87%
8192	4766.49%	1/2	99.07%

--precision_margin व्युत्पन्न न्यूनतम से ऊपर की गुंजाइश को समायोजित करता है; न्यूनतम स्वयं लागू किया जाता है।

सत्यापित समाप्ति

एल्गोरिद्म 3 तब रुकता है जब (L + R) / 2 - d_s (-0.5, 0.5] में आता है। वह परीक्षण तब सक्रिय हो सकता है जब अंतराल 1 से संकरा हो, और विंडो [mid - 0.5, mid + 0.5) तब इसे ले जाने वाले अंतराल से अधिक चौड़ी होती है। विपरीत रोटेशन अंतराल चौड़ाई के मॉड्यूलो एक आइसोमेट्री है, इसलिए कट को पार करने वाली विंडो रिसीवर को d_s से एक पूरे अंतराल दूर छोड़ देती है।

इसलिए प्रेषक रुकने का निर्णय लेने से पहले रिसीवर के विपरीत रोटेशन को दोहराता है और यदि रीप्ले गुप्त संदेश नहीं लौटाता तो एक और टोकन उत्सर्जित करता है। रीप्ले शुद्ध Decimal कार्य है (फ़ॉरवर्ड पास के ~20 ms के विरुद्ध ~0.05 ms), इसलिए गार्ड की कोई मापनीय लागत नहीं है। --no_verify इसे अक्षम कर देता है।

Llama-2-7b पर मापा गया:

बिट्स	गार्ड के बिना पुनः प्राप्त	इसके साथ
128	291/300 (97.0%)	300/300
512	64/65 (98.5%)	40/40
1024	20/20	20/20
2048	10/10	10/10

128 बिट्स पर गार्ड की लागत 0.095% अतिरिक्त उत्पन्न टोकन थी। 1024 और 2048 बिट्स के नमूने दर को सीमित करने के लिए बहुत कम हैं — 3% दर पर 0/20 होना न होने से अधिक संभावित परिणाम है — इसलिए वे इस बात का प्रमाण नहीं हैं कि लंबे संदेश अलग व्यवहार करते हैं। गार्ड के साथ, 370/370 पुनः प्राप्त हुए।