चित्रातला एन्क्रिप्टेड संदेश: SnapSeal कोडेकच्या आत

गुपित आणि कव्हर यांची वेगळी कामे

SnapSeal प्रतिमा, फाइल किंवा मजकुराचे मूळ बाइट आणि त्यांचा मेटाडेटा एन्क्रिप्ट करतो. तयार झालेले आवरण तो कव्हर प्रतिमेच्या पिक्सेलमध्ये ठेवतो. ते उघडण्यासाठी प्राप्तकर्त्याला संरक्षित फाइल आणि पासवर्ड लागतो; सर्व्हर किंवा मूळ कव्हर लागत नाही.

क्रिप्टोग्राफी सामग्रीची गोपनीयता राखते, तर इमेज स्टेगनोग्राफी तिला वाहक पुरवते. दोन्ही कल्पना आधीपासून परिचित आहेत. या उदाहरणातील चित्र आणि चाचणी पासवर्ड जाणूनबुजून सार्वजनिक केलेले आहेत.

1. original_bytes + metadata
2. Argon2id → AES-GCM
3. header + ciphertext + tag
4. RGB → PNG

original.pngcover.webpprotected.png

खालचे दोन बिट वापरा

प्रत्येक RGB पिक्सेलमध्ये तीन 8-बिट चॅनेल असतात. या उदाहरणात एन्कोडर चॅनेल डावीकडून उजवीकडे वाचतो, अल्फा वगळतो आणि वरचे सहा बिट कायम ठेवून खालचे दोन बदलतो. अशा चार चॅनेलमध्ये एक बाइट साठतो.

ठळक केलेले बिट कसे बदलतात ते पाहण्यासाठी स्लायडर हलवा. केवळ या लो-बिट लेखनामुळे चॅनेलचे मूल्य जास्तीत जास्त 3 ने बदलते; ऐच्छिक JPEG वाहक किंवा इतर सजावटीमुळे कव्हरमध्ये याहून मोठा बदल होऊ शकतो.

def embed_byte(channels: bytes, value: int) -> bytes:
    if len(channels) != 4 or not 0 <= value <= 255:
        raise ValueError("Expected four channels and one byte")
    pairs = [(value >> shift) & 3 for shift in (6, 4, 2, 0)]
    return bytes((c & 0xFC) | pair
                 for c, pair in zip(channels, pairs, strict=True))

def read_byte(channels: bytes) -> int:
    value = 0
    for channel in channels:
        value = (value << 2) | (channel & 3)
    return value

cover = bytes([170, 181, 94, 203])
stored = embed_byte(cover, 0xD3)
assert stored == bytes([171, 181, 92, 203])
assert read_byte(stored) == 0xD3

किती बाइट मावतात?

तीन चॅनेलमध्ये प्रत्येकी दोन बिट म्हणजे एका पिक्सेलमध्ये सहा बिट. 1024×1024 कव्हरमध्ये 16-बाइट पिक्सेल-पॅकेट हेडरच्या आधी 786,432 बाइट मावतात; हेडरनंतर 786,416 बाइट उरतात. चित्रासाठी काही पिक्सेल राखीव ठेवल्यामुळे क्षमता कमी होते.

एक निश्चित खूण पॅकेटची मांडणी ओळखते आणि लांबीवरून आवरणाचा शेवट कळतो. पॅकेट आणि एन्क्रिप्शन यांच्या आवृत्त्यांच्या क्रमांकन पद्धती वेगळ्या आहेत: PNG2 पॅकेटमध्ये v3 क्रिप्टोग्राफिक आवरण असू शकते.

C = floor(W × H × 3 × 2 / 8) − 16
C(1024, 1024) = 786,416 bytes

की तयार करा, आवरणाची सत्यता तपासा

SnapSealचा v3 प्रोफाइल UTF-8 पासवर्ड आणि यादृच्छिक 16-बाइट सॉल्टपासून Argon2id v1.3 वापरून 32-बाइट की तयार करतो. त्यासाठी 64 MiB मेमरी, तीन पास आणि एक लेन वापरली जाते. KDF चालवण्यापूर्वी रीडरने समर्थित व निश्चित केलेले वर्क फॅक्टर तपासले पाहिजेत.

AES-256-GCM मूळ बाइट आणि मेटाडेटा एन्क्रिप्ट करतो. त्याचा 16-बाइट टॅग सायफरटेक्स्ट आणि सार्वजनिक 48-बाइट हेडर या दोहोंची सत्यता पडताळतो. प्रमाणीकरण अयशस्वी झाल्यास रीडरने प्लेनटेक्स्ट कधीही उपलब्ध करून देऊ नये.

from argon2.low_level import Type, hash_secret_raw
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def decrypt_v3(envelope: bytes, password: str) -> bytes:
    if not 70 <= len(envelope) <= 50 * 1024 * 1024 + 4096:
        raise ValueError("Invalid envelope size")
    header = envelope[:48]
    if header[:12] != b"SNAPSEAL\x03\x01\x13\x01":
        raise ValueError("Expected the v3 Argon2id profile")
    memory = int.from_bytes(header[12:16], "big")
    passes = int.from_bytes(header[16:20], "big")
    if (memory, passes) != (65536, 3):
        raise ValueError("Unsupported work factors")
    secret = password.encode("utf-8")
    if not 1 <= len(password) <= 256 or len(secret) > 1024:
        raise ValueError("Invalid password length")
    key = hash_secret_raw(
        secret, header[20:36], time_cost=passes,
        memory_cost=memory, parallelism=1, hash_len=32,
        type=Type.ID, version=19,
    )
    return AESGCM(key).decrypt(
        header[36:48], envelope[48:], header,
    )

plaintext = uint32_be(metadata_length) + metadata_json + original_bytes
envelope  = header + AESGCM(key).encrypt(nonce, plaintext, header)

संदेश पिक्सेलमध्ये असतो

संदेश डिकोड केलेल्या RGB मूल्यांमध्ये असतो, PNG मेटाडेटामध्ये नाही. दोन PNG फाइलचे बाइट वेगळे असले तरी डिकोड केलेली RGB मूल्ये बदलली नसतील, तर त्यांतील लो-बिट संदेश टिकतो. उलट स्क्रीनशॉट, पिक्सेलमधील संपादन किंवा आकार बदलल्याने चित्र ओळखू येत असले तरी डेटा नष्ट होऊ शकतो.

स्रोत संपीडन स्पष्टपणे निवडले नसेल, तर पुनर्प्राप्तीमध्ये मूळ बाइट आणि मेटाडेटा तंतोतंत परत मिळतात. फाइलचे नाव एन्क्रिप्ट केलेले असते; मात्र पॅडिंग नसल्यास आवरणातून अंदाजे आकार कळू शकतो.

PNG bytes A ≠ PNG bytes B
RGB(A) = RGB(B), α(A) = α(B) = 255
→ envelope(A) = envelope(B)

अँटी-कम्प्रेशन: JPEGमधून पुनर्प्राप्तीचा दुसरा मार्ग

अँटी-कम्प्रेशन म्हणजे आकारमान न बदललेल्या JPEGमधून डेटा परत मिळवण्याचा शक्य तितका प्रयत्न. एकाच एन्क्रिप्टेड आवरणाची हानीविरहित प्रत PNGच्या खालच्या RGB बिटमध्ये असते; ऐच्छिक पुनर्प्राप्ती प्रत प्रतिमेच्या फ्रिक्वेन्सी गुणांकांमध्ये ठेवता येते.

यामुळे संपीडन रोखले जात नाही, कोणत्याही मेसेंजरमधून डेटा टिकेल याची हमी मिळत नाही आणि स्वरूप शोधता येणार नाही असेही होत नाही.

RGB → Y → DCT(8×8)
q = round(coefficient / JPEG_quantizer)
coefficient′ = q × JPEG_quantizer

from math import floor

def put_bit(coefficient: float, bit: int, step: int = 24) -> int:
    cell = floor((coefficient / step - bit) / 2 + 0.5)
    return step * (2 * cell + bit)

def read_bit(coefficient: float, step: int = 24) -> int:
    return floor(coefficient / step + 0.5) % 2

stored = put_bit(70, 1)              # 72
assert read_bit(stored + 11) == 1    # 83: same cell
assert read_bit(stored + 13) == 0    # 85: crossed the boundary

223 + 32 = 255 bytes
t = (255 − 223) / 2 = 16 byte errors
A₀ B₀ C₀ A₁ B₁ C₁ … → A, B, C
repair → CRC → AES-GCM → original_bytes

exact(PNG) ∧ exact(Q60) ∧ exact(Q85 → Q60)
max(corrected_bytes_per_codeword) ≤ 12 < 16
automatic: envelope_length ≤ 280_000

स्वरूप काय उघड करते?

निश्चित खुणांमुळे हे स्वरूप ओळखता येते. कव्हर चित्र सार्वजनिक असते आणि चित्र म्हणून त्याची सत्यता प्रमाणित केली जात नाही; त्याचे वरचे बिट बदलले तरी आतला संदेश टिकू शकतो. त्रुटी-दुरुस्ती आणि CRC ट्रान्सपोर्टमधील नुकसान हाताळतात, तर AES-GCM संरक्षित सामग्रीची सत्यता पडताळतो.

हल्लेखोर ऑफलाइन पासवर्डचा अंदाज लावण्याचा प्रयत्न करू शकतो. Argon2id प्रत्येक अंदाज महाग करतो, पण कमकुवत पासवर्ड सुरक्षित करू शकत नाही. पासवर्ड पुनर्प्राप्तीची सोय नाही आणि स्वतंत्र सुरक्षा ऑडिट झाल्याचाही दावा नाही.

ॲपशिवाय फाइल वाचा

या स्वरूपात परिचित क्रिप्टोग्राफिक साधने वापरली आहेत; त्याची रचना आणि मर्यादा स्पष्ट आहेत आणि स्वतंत्र रीडर उपलब्ध आहे. Python 3.12+ रीडर मूळ PNG वाचतो; JPEG पुनर्प्राप्ती प्रत असलेले PNGही त्यात येतात. तो मर्यादित आकाराचे, एकच PNG असलेले SnapSeal ZIP आणि raw v3 आवरणेही वाचतो. JPEGमध्ये रूपांतरित केलेल्या फाइलसाठी मात्र TypeScript कोडेक लागतो.

येथे वर्णन केलेली अंमलबजावणी ओपन-सोर्स v3 आहे; आधीपासून तैनात असलेले जुने रीडर तिचा आउटपुट नाकारू शकतात. दिलेली अवलंबित्वे व्हर्च्युअल वातावरणात इन्स्टॉल करा. पूर्ण स्रोत आणि ऐच्छिक डाउनलोड्स उदाहरणांनंतर आहेत.

python -m pip install -r requirements.txt

from getpass import getpass
from pathlib import Path
from decode_snapseal import decode_path

result = decode_path(
    Path("protected.png"),
    getpass("Password: "),
)

output = Path("restored")
output.mkdir(exist_ok=True)
with (output / result.filename).open("xb") as target:
    target.write(result.data)