Krüptitud sõnum pildi sees: kuidas SnapSeali koodek töötab

Saladus ja kandjapilt

SnapSeal krüptib piltide, failide või teksti algsed baidid koos metaandmetega ning peidab saadud ümbrise kandjapilti. Kaitstud faili avamiseks vajab saaja parooli, kuid mitte serverit ega algset kandjapilti.

Krüptograafia hoiab sisu konfidentsiaalsena, pildisteganograafia annab sellele kandja. Kumbki võte pole uus. Näites kasutatud illustratsioon ja testparool on teadlikult avaldatud.

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

original.pngcover.webpprotected.png

Kaks alumist bitti

Igal RGB-pikslil on kolm 8-bitist kanalit. Selles näites loeb kodeerija kanaleid vasakult paremale, jätab alfakanali vahele, säilitab iga kanali 6 ülemist bitti ja asendab 2 alumist. Nii mahub 1 bait 4 kanalisse.

Liiguta liugurit, et näha esiletõstetud bittide muutumist. Ainuüksi see alumiste bittide kirjutamine muudab kanali väärtust kuni 3 võrra; valikuline JPEG-taastekanal ja muu kujundus võivad kandjapilti rohkem muuta.

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

Kui palju andmeid pildile mahub?

Kolm kanalit, igas 2 bitti, annavad piksli kohta 6 bitti. 1024×1024 kandjapilti mahub enne 16-baidist pikslipaketi päist 786 432 baiti; pärast päist jääb 786 416 baiti. Illustratsioon reserveerib osa piksleid ja vähendab mahtu.

Kindel marker määrab paketi paigutuse ning pikkus näitab, kus ümbris lõpeb. Paketi ja krüptimise versiooninumbrid kuuluvad eri nimeruumidesse: PNG2-pakett võib kanda v3 krüptograafilist ümbrist.

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

Võtme tuletamine ja ümbrise autentimine

SnapSeali v3-profiil kasutab Argon2id v1.3 algoritmi, et tuletada UTF-8-vormingus paroolist ja juhuslikust 16-baidisest soolast 32-baidine võti. Selleks kulub 64 MiB mälu, 3 läbimist ja 1 rada. Lugeja peab enne võtme tuletamist kontrollima, et tööparameetrid vastavad toetatud kindlatele väärtustele.

AES-256-GCM krüptib algsed baidid ja metaandmed. Selle 16-baidine autentimismärgend autendib nii krüptoteksti kui ka avaliku 48-baidise päise. Kui autentimine ebaõnnestub, ei tohi lugeja avateksti väljastada.

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)

Sõnum on pikslites

Andmed asuvad dekodeeritud RGB-väärtustes, mitte PNG-metaandmetes. Kahe PNG-faili baidid võivad erineda, kuid kui nende dekodeeritud RGB-väärtused on samad, säilib ka alumistesse bittidesse kirjutatud sõnum. Kuvatõmmis, pikslite muutmine või suuruse muutmine võib seevastu andmed hävitada, kuigi pilt jääb äratuntavaks.

Kui lähteandmete pakkimist pole eraldi valitud, taastuvad algsed baidid ja metaandmed täpselt. Failinimi on krüptitud, kuid ilma täiteandmeteta reedab ümbris siiski ligikaudse suuruse.

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

Pakkimisvastane kaitse: teine tee läbi JPEG-i

Pakkimisvastane kaitse püüab andmeid taastada JPEG-ist, mille mõõtmed on jäänud samaks. See on parima võimaliku tulemuse poole püüdlev lahendus, mitte garantii. Samast krüptitud ümbrisest on kadudeta koopia PNG RGB-kanalite alumistes bittides ja soovi korral taastekoopia pildi sageduskordajates.

See ei takista pakkimist ega luba, et andmed peavad vastu suvalise sõnumirakenduse töötlusele. Samuti ei muuda see vormingut tuvastamatuks.

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

Mida vorming välja annab

Kindlad markerid teevad vormingu tuvastatavaks. Kandjapildi illustratsioon on avalik ja seda ei autentita illustratsioonina; selle ülemiste bittide muutmine võib peidetud sõnumi puutumata jätta. Veaparandus ja CRC tegelevad edastuskahjustustega, AES-GCM aga autendib kaitstud sisu.

Ründaja saab paroole endiselt võrguühenduseta ära arvata. Argon2id muudab iga katse kulukamaks, kuid nõrka parooli see ei päästa. Parooli taastada ei saa ning siin ei väideta, et lahendus oleks läbinud sõltumatu turvaauditi.

Lugemine ilma rakenduseta

Allalaaditav Python 3.12+ lugeja toetab algseid PNG-faile, sealhulgas JPEG-taastekoopiaga PNG-sid, piiratud mahuga ühe PNG-ga SnapSeali ZIP-faile ja tooreid v3-ümbriseid. Teisendatud JPEG-failide lugemiseks on vaja TypeScripti koodekit.

Siin kirjeldatud v3-teostus on avatud lähtekoodiga; varem kasutusele võetud lugejad võivad selle väljundi tagasi lükata. Paigalda loetletud sõltuvused virtuaalkeskkonda. Täielik lähtekood ja valikulised allalaaditavad failid järgnevad tekstisisestele näidetele.

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)