Isang naka-encrypt na mensahe sa larawan: sa loob ng codec ng SnapSeal

Ihiwalay ang lihim sa larawang nagdadala nito

Kinukuha ng SnapSeal ang mga orihinal na byte ng mga larawan, file o teksto. Ini-encrypt nito ang mga byte at metadata, saka inilalagay ang nabuong envelope sa isang cover image. Para ma-decode ang protektadong file, kailangan ng tatanggap ang password, pero hindi ang server o orihinal na cover.

Cryptography ang nagpapanatiling kumpidensiyal sa nilalaman; image steganography naman ang nagbibigay ng tagapagdala. Parehong kilalang ideya ang mga ito. Sadyang pampubliko ang artwork at test password sa demo.

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

original.pngcover.webpprotected.png

Gamitin ang dalawang pinakamababang bit

Bawat RGB pixel ay may tatlong 8-bit channel. Sa halimbawang ito, binabasa ng encoder ang mga channel mula kaliwa pakanan, nilalaktawan ang alpha, pinananatili ang anim na pinakamataas na bit at pinapalitan ang dalawang pinakamababa. Kaya nakapagdala ng isang byte ang apat na channel.

Igalaw ang slider para makita ang pagbabago sa mga naka-highlight na bit. Sa pagsulat na ito sa mabababang bit lamang, hanggang 3 ang maaaring maging pagbabago sa halaga ng isang channel. Maaaring mas malaki ang pagbabago dahil sa opsyonal na JPEG carrier o iba pang pag-istilo ng cover.

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

Bilangin ang magagamit na espasyo

Sa tatlong channel na may tig-dalawang bit, may anim na bit bawat pixel. Ang 1024×1024 na cover ay may kapasidad na 786,432 byte bago ang 16-byte pixel-packet header, o 786,416 byte pagkatapos nito. May mga pixel ding inilalaan para sa artwork, kaya nababawasan ang kapasidad.

Isang nakapirming marker ang tumutukoy sa layout ng packet, at isang length field ang nagsasaad kung saan nagtatapos ang envelope. Magkahiwalay ang mga namespace ng bersiyon ng packet at ng encryption: maaaring maglaman ang PNG2 packet ng v3 cryptographic envelope.

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

Buuin ang key at patunayan ang envelope

Sa v3 profile ng SnapSeal, gumagamit ang Argon2id v1.3 ng UTF-8 password at random na 16-byte salt upang bumuo ng 32-byte key. Nakatakda ito sa 64 MiB na memory, tatlong pass at isang lane. Dapat munang tiyakin ng reader na suportado ang mga nakapirming work factor bago patakbuhin ang KDF.

Ini-encrypt ng AES-256-GCM ang orihinal na mga byte at metadata. Pinatutunayan ng 16-byte tag nito ang ciphertext at ang pampublikong 48-byte header. Kapag nabigo ang authentication, hindi dapat maglabas ang reader ng plaintext.

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)

Nasa mga pixel ang mensahe

Nasa decoded RGB values ang payload, hindi sa PNG metadata. Maaaring magkaiba ang mga byte ng dalawang PNG file ngunit pareho pa rin ang mensahe sa mabababang bit kung hindi nagbago ang decoded RGB values. Sa kabilang banda, maaaring sirain ng screenshot, pag-edit ng pixel o pag-resize ang data kahit nakikilala pa ang larawan.

Maliban kung tahasang pinili ang source compression, eksaktong naibabalik ang orihinal na mga byte at metadata. Naka-encrypt ang filename, pero kung walang padding, makikita pa rin ang tinatayang laki mula sa envelope.

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

Anti-compression: pangalawang daan sa JPEG

Ang anti-compression ay pagtatangkang mabawi ang data mula sa JPEG na nanatili sa parehong sukat. Ang iisang naka-encrypt na envelope ay may lossless na kopya sa mabababang RGB bit ng PNG at, kung pinili, recovery copy sa mga frequency coefficient ng larawan.

Hindi nito pinipigilan ang compression o ginagarantiyang makakaligtas ang data sa anumang messenger. Hindi rin nito ginagawang hindi matukoy ang format.

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

Alamin kung ano ang nakalantad

Natutukoy ang format dahil sa mga nakapirming marker. Pampubliko ang cover artwork at hindi ito pinatutunayan bilang artwork; maaaring manatiling buo ang naka-embed na mensahe kahit baguhin ang matataas na bit nito. Error correction at CRC ang tumutugon sa pinsala sa transport, samantalang AES-GCM ang nagpapatunay sa protektadong nilalaman.

Maaari pa ring manghula ng password ang isang attacker offline. Pinapataas ng Argon2id ang gastos sa bawat hula, pero hindi nito maililigtas ang mahinang password. Walang password recovery, at walang inaangking independent security audit.

Basahin ang file nang wala ang application

Gumagamit ang format ng mga kilalang cryptographic primitive, may tahasang mga limitasyon at maaaring basahin ng isang independent reader. Sinusuportahan ng Python 3.12+ reader ang mga orihinal na PNG, kabilang ang may JPEG recovery copy, mga single-PNG SnapSeal ZIP na may takdang limitasyon, at raw v3 envelope. Kailangan ang TypeScript codec para sa mga file na na-convert sa JPEG.

Ang inilalarawan dito ay ang open-source v3 implementation; maaaring tanggihan ng mga lumang deployed reader ang output nito. I-install sa virtual environment ang mga nakalistang dependency. Kasunod ng mga halimbawa ang buong source at mga opsyonal na download.

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)