Titkosított üzenet a képben: így működik a SnapSeal kodekje

A titok és a hordozó különválasztása

A SnapSeal képek, fájlok vagy szövegek eredeti bájtjaiból indul ki. Titkosítja ezeket és a metaadataikat, majd a kapott csomagot egy fedőképbe ágyazza. A visszafejtéshez a címzettnek a védett fájlra és a jelszóra van szüksége; az eredeti fedőkép nem kell.

A bizalmasságot a kriptográfia adja, a képi szteganográfia pedig a hordozóról gondoskodik. Egyik eljárás sem új. A bemutató fedőképe és tesztjelszava szándékosan nyilvános.

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

original.pngcover.webpprotected.png

Az alsó két bit felhasználása

Egy RGB-pixel három, egyenként 8 bites csatornából áll. A példában a kódoló balról jobbra olvassa a csatornákat, az alfacsatornát kihagyja, a felső hat bitet megtartja, az alsó kettőt pedig lecseréli. Négy csatornában így egy bájt fér el.

Mozgasd a csúszkát, és figyeld a kiemelt biteket. Ez az önmagában vizsgált írás csatornánként legfeljebb 3-mal módosítja az értéket; az opcionális JPEG-hordozó és a kép egyéb alakítása ennél nagyobb változást is okozhat.

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

Mennyi adat fér el?

Három csatorna két-két bitje pixelenként hat bitet ad. Egy 1024×1024-es fedőképben ez 786 432 bájt, amiből a 16 bájtos pixelcsomag-fejléc után 786 416 marad. A grafika pixeleket foglal le, ezért csökkenti a kapacitást.

A csomag elrendezését rögzített jelölő azonosítja, a csomagban megadott hossz pedig kijelöli a titkosított csomag végét. A pixelcsomag és a titkosítás verziószámai egymástól függetlenek: egy PNG2 csomag v3 titkosított csomagot is hordozhat.

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

Kulcsszármaztatás és hitelesítés

A SnapSeal v3 profilja az Argon2id v1.3 segítségével 32 bájtos kulcsot származtat az UTF-8 kódolású jelszóból és egy véletlen, 16 bájtos sóból. Ehhez 64 MiB memóriát, három menetet és egy sávot használ. Az olvasónak még a kulcsszármaztatás előtt ellenőriznie kell, hogy a rögzített munkaparaméterek a támogatott értékek-e.

Az AES-256-GCM az eredeti bájtokat és a metaadatokat titkosítja. A 16 bájtos hitelesítő címke a titkosított adatokat és a nyilvános, 48 bájtos fejlécet is védi. Sikertelen hitelesítés után az olvasó semmiképpen sem adhat ki nyílt szöveget.

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)

Az üzenet a pixelekben van

A beágyazott adat a dekódolt RGB-értékekben található, nem a PNG metaadataiban. Két PNG fájl bájtjai eltérhetnek egymástól úgy is, hogy azonos dekódolt RGB-értékeik ugyanazt az alsó bitekbe írt üzenetet őrzik. Egy képernyőkép, pixelmódosítás vagy átméretezés viszont akkor is tönkreteheti az adatokat, ha a kép felismerhető marad.

Ha a felhasználó nem választott kifejezetten forrástömörítést, az eredeti bájtok és metaadatok pontosan helyreállnak. A fájlnév titkosítva van, de kitöltés nélkül a csomag hozzávetőleges mérete továbbra is látszik.

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

Tömörítés ellen: második út a JPEG-en át

A tömörítés elleni védelem azonos méretű JPEG esetén megkísérli az adatok helyreállítását, de nem garantálja azt. Ugyanannak a titkosított csomagnak van egy veszteségmentes másolata a PNG alsó RGB-bitjeiben, és opcionálisan egy helyreállítási másolata a kép frekvencia-együtthatóiban.

Ez nem akadályozza meg a tömörítést, és nem ígér túlélést tetszőleges üzenetküldőkön keresztül. A formátumot sem teszi felismerhetetlenné.

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

Mit árul el a formátum?

A rögzített jelölők alapján a formátum felismerhető. A fedőkép nyilvános, és képként nincs hitelesítve: felső bitjeinek módosítása akár érintetlenül is hagyhatja a beágyazott üzenetet. A hibajavítás és a CRC az átviteli sérülésekkel foglalkozik, a védett tartalmat az AES-GCM hitelesíti.

A jelszavak offline is próbálgathatók. Az Argon2id minden próbát költségesebbé tesz, de egy gyenge jelszót nem ment meg. Jelszó-helyreállítás nincs, és a leírás nem állítja, hogy független biztonsági audit történt.

Olvasás az alkalmazás nélkül

A formátum ismert kriptográfiai építőelemekre, egyértelműen megadott korlátokra és egy független olvasóra támaszkodik. A Python 3.12+ rendszeren futó olvasó eredeti PNG-ket olvas, köztük JPEG-helyreállítási másolatot is tartalmazó PNG-ket, továbbá korlátozott méretű, egyetlen PNG-t tartalmazó SnapSeal ZIP-eket és nyers v3 titkosított csomagokat. Átalakított JPEG-fájlokhoz a TypeScript-kodek szükséges.

A cikk a nyílt forráskódú v3-implementációt mutatja be; a régebben kiadott olvasók elutasíthatják a fájljait. A megadott függőségeket virtuális környezetbe telepítsd. A teljes forráskód és az opcionális letöltések a példák után következnek.

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)