Ett krypterat meddelande i en bild: så fungerar SnapSeals kodek

Skilj hemligheten från omslagsbilden

SnapSeal utgår från originalets byte, oavsett om de kommer från bilder, filer eller text. Kodeken krypterar dem tillsammans med metadata och bäddar sedan in kuvertet i en omslagsbild. Mottagaren behöver den skyddade filen och lösenordet, men ingen server eller ursprunglig omslagsbild.

Kryptografin skyddar innehållets sekretess; steganografin tillhandahåller bäraren. Båda teknikerna är etablerade. Utmaningen är att göra gränserna mellan dem tydliga. I det här exemplet är både omslagsbilden och testlösenordet avsiktligt offentliga.

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

original.pngcover.webpprotected.png

Använd de två lägsta bitarna

Varje RGB-pixel har tre 8-bitarskanaler. I exemplet läser kodaren kanalerna från vänster till höger, hoppar över alfa, bevarar de sex högsta bitarna och ersätter de två lägsta. Fyra kanaler kan därmed bära en byte.

Flytta reglaget för att se de markerade bitarna ändras. Just denna skrivning av låga bitar ändrar en kanals värde med högst 3. Den valfria JPEG-bäraren och annan bearbetning av omslaget kan ändra bilden mer än så.

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

Räkna ut kapaciteten

Tre kanaler med två bitar vardera ger sex bitar per pixel. Ett omslag på 1024×1024 har plats för 786 432 byte före pixelpaketets 16 byte långa huvud och 786 416 byte efter det. Illustrationer reserverar pixlar och minskar kapaciteten.

En fast markör identifierar paketets format och en längduppgift anger var kuvertet slutar. Paketversioner och krypteringsversioner är separata: ett PNG2-paket kan bära ett kryptografiskt v3-kuvert.

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

Härled nyckeln och autentisera kuvertet

SnapSeals v3-profil använder Argon2id v1.3 för att härleda en nyckel på 32 byte från lösenordet i UTF-8 och ett slumpmässigt salt på 16 byte. Inställningarna är 64 MiB minne, tre genomgångar och ett spår. En läsare måste kontrollera att arbetsfaktorerna är de fasta värden som stöds innan nyckelhärledningen körs.

AES-256-GCM krypterar originalets byte och metadata. En tagg på 16 byte autentiserar kryptotexten och det offentliga huvudet på 48 byte. Om autentiseringen misslyckas får läsaren aldrig lämna ut klartext.

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)

Meddelandet finns i pixlarna

Nyttolasten ligger i avkodade RGB-värden, inte i PNG-metadata. Två PNG-filer kan ha olika filinnehåll på bytenivå och ändå bevara samma meddelande i de låga bitarna, så länge de avkodade RGB-värdena är oförändrade. En skärmbild, pixelredigering eller storleksändring kan däremot förstöra datan medan bilden fortfarande går att känna igen.

Om källkomprimering inte uttryckligen har valts återställs originalets byte och metadata exakt. Filnamnet är krypterat, men utan utfyllnad avslöjar kuvertet fortfarande den ungefärliga storleken.

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

Antikomprimering: en andra väg genom JPEG

Antikomprimering är ett försök att återställa data ur JPEG-bilder som har kvar samma dimensioner. Samma krypterade kuvert finns då både som en förlustfri kopia i PNG-bildens låga RGB-bitar och, om funktionen valts, som en återställningskopia i bildens frekvenskoefficienter.

Det hindrar inte komprimering och lovar inte att datan överlever godtyckliga meddelandetjänster. Formatet blir inte heller omöjligt att upptäcka.

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

Vad formatet avslöjar

Fasta markörer gör formatet upptäckbart. Omslagsbilden är offentlig och autentiseras inte som illustration; ändringar i dess höga bitar kan lämna det inbäddade meddelandet intakt. Felkorrigering och CRC hanterar transportskador, medan AES-GCM autentiserar det skyddade innehållet.

En angripare kan fortfarande gissa lösenord offline. Argon2id gör varje gissning dyrare men kan inte rädda ett svagt lösenord. Det finns ingen lösenordsåterställning, och detta är inte ett påstående om att en oberoende säkerhetsgranskning har gjorts.

Läs filen utan applikationen

Den oberoende läsaren för Python 3.12+ stöder ursprungliga PNG-filer, även sådana med en JPEG-återställningskopia, SnapSeal-ZIP-filer med en enda PNG inom de begränsningar som stöds samt råa v3-kuvert. JPEG-filer som konverterats från omslaget kräver TypeScript-kodeken.

Formatet som beskrivs här är v3-implementationen med öppen källkod. Äldre driftsatta läsare kan avvisa dess filer. Lösningen bygger på befintliga kryptografiska primitiver, ett format med tydliga gränser och en oberoende läsare. Installera de angivna beroendena i en virtuell miljö. Fullständig källkod och valfria nedladdningar följer efter kodexemplen i artikeln.

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)