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

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

पेपर: Efficient Provably Secure Linguistic Steganography via Range Coding

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

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

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

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

.
├── RRC_embed.py   # एम्बेडिंग (एल्गोरिदम 3) 
├── RRC_extract.py   # निकालना (एल्गोरिदम 4) 
├── test_roundtrip.py         # स्व-निहित एंड-टू-एंड सत्यापन स्क्रिप्ट
├── requirements.txt          # Python निर्भरताएँ
└── README.md

आवश्यकताएँ

• Python ≥ 3.10
• PyTorch ≥ 2.0
• Transformers ≥ 4.35

निर्भरताएँ स्थापित करें:

pip install -r requirements.txt

त्वरित प्रारंभ

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

राउंड-ट्रिप परीक्षण meta-llama/Llama-2-7b-hf का उपयोग करता है और CPU/CUDA पर चलता है:

python test_roundtrip.py

अपेक्षित आउटपुट:

>>> Step 3: Verification
    Original: 10110011001010111010011100101011...
    Extracted: 10110011001010111010011100101011...

    ✅ SUCCESS — extracted message matches perfectly!

2. एक गुप्त संदेश एम्बेड करें

एक प्रॉम्प्ट्स फ़ाइल 0.Prompts.tsv तैयार करें जिसमें कॉलम idx और text हों, फिर चलाएँ:

python RRC_embed.py \
    --language_model meta-llama/Llama-3.1-8B \
    --bit_length 128 \
    --key 42 \
    --top_k -1

3. गुप्त संदेश निकालें

python RRC_extract.py \
    --language_model meta-llama/Llama-3.1-8B \
    --bit_length 128 \
    --key 42 \
    --input_file 1.RC_decimal_Llama-3.1-8B_bit128.tsv

⚠️ महत्वपूर्ण: प्रेषक और प्राप्तकर्ता को सही निष्कर्षण के लिए समान भाषा मॉडल, कुंजी, बिट लंबाई और top-k सेटिंग का उपयोग करना चाहिए।

CLI तर्क

RRC_embed.py

RRC_extract.py

तकनीकी नोट: दशमलव मॉड्यूलो

Python का Decimal प्रकार % ऑपरेटर के लिए छोटा विभाजन का उपयोग करता है, जो ऋणात्मक शेषफल लौटा सकता है (उदाहरण: Decimal('-19672') % Decimal('65536') → 45864 के बजाय -19672)। यह कार्यान्वयन एक decimal_mod हेल्पर का उपयोग करता है जो गारंटी देता है कि परिणाम हमेशा [0, m) में हो:

def decimal_mod(a, m):
    return a - m * (a / m).to_integral_value(rounding=ROUND_FLOOR)

⚠️ विश्वसनीय गुप्त निष्कर्षण के लिए, CUDA गैर-नियतिवाद से बचने के लिए कुछ संचालन (sort, cumsum) को float64 परिशुद्धता पर CPU पर ऑफलोड किया जाता है। यह गारंटीड एनकोड-डीकोड स्थिरता के लिए कुछ गति का व्यापार करता है।