Un messaggio cifrato in un’immagine: dentro il codec di SnapSeal

Separare il segreto dall’immagine di copertura

SnapSeal parte dai byte originali di immagini, file o testi. Il codec li cifra insieme ai metadati, poi inserisce l’involucro risultante in un’immagine di copertura. Per recuperare il contenuto servono il file protetto e la password, ma non la copertura originale.

La crittografia protegge la riservatezza; la steganografia delle immagini fornisce il supporto. Nessuna delle due idee è nuova. L’illustrazione della demo e la relativa password di prova sono volutamente pubbliche.

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

original.pngcover.webpprotected.png

Usare i due bit meno significativi

Ogni pixel RGB ha tre canali a 8 bit. In questo esempio la codifica percorre i canali da sinistra a destra, salta l’eventuale canale alfa, conserva i sei bit superiori e sostituisce i due inferiori. Bastano quindi quattro canali per contenere un byte.

Sposta il cursore per vedere cambiare i bit evidenziati. Questa sola scrittura nei bit inferiori modifica il valore di un canale al massimo di 3; il supporto JPEG opzionale e altre modifiche grafiche possono alterare maggiormente la copertura.

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

Calcolare lo spazio disponibile

Tre canali con due bit ciascuno danno sei bit per pixel. Una copertura da 1024×1024 pixel offre 786.432 byte prima dell’intestazione di 16 byte del pacchetto nei pixel: ne restano 786.416 dopo averla sottratta. L’illustrazione riserva una parte dei pixel e riduce la capacità.

Un marcatore fisso identifica la struttura del pacchetto, mentre un campo di lunghezza delimita l’involucro. Le versioni del pacchetto e quelle della cifratura appartengono a spazi distinti: un pacchetto PNG2 può contenere un involucro crittografico v3.

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

Derivare la chiave e autenticare l’involucro

Il profilo v3 di SnapSeal usa Argon2id v1.3 per derivare una chiave di 32 byte dalla password codificata in UTF-8 e da un salt casuale di 16 byte. I parametri prevedono 64 MiB di memoria, tre passaggi e una corsia. Prima di eseguire la derivazione, un lettore deve verificare che i parametri di costo siano quelli fissi supportati.

AES-256-GCM cifra i byte originali e i metadati. Il suo tag di 16 byte autentica il testo cifrato e l’intestazione pubblica di 48 byte. Se l’autenticazione fallisce, il lettore non deve mai rilasciare il testo in chiaro.

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)

Sono i pixel a trasportare il messaggio

I dati si trovano nei valori RGB decodificati, non nei metadati PNG. Due file PNG possono avere byte diversi e conservare lo stesso messaggio nei bit inferiori, purché i valori RGB decodificati rimangano identici. Uno screenshot, una modifica dei pixel o un ridimensionamento possono invece distruggere i dati lasciando l’immagine riconoscibile.

A meno che non sia stata esplicitamente selezionata la compressione della sorgente, il recupero restituisce esattamente i byte originali e i metadati. Il nome del file è cifrato, ma senza padding l’involucro ne rivela comunque la dimensione approssimativa.

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

Anticompressione: una seconda via attraverso JPEG

L’anticompressione è un tentativo di recupero, senza garanzia di successo, per i JPEG che mantengono le stesse dimensioni. Lo stesso involucro cifrato ha una copia senza perdita nei bit inferiori RGB del PNG e, facoltativamente, una copia di recupero nei coefficienti di frequenza dell’immagine.

Questo meccanismo non impedisce la compressione, non promette di sopravvivere al passaggio attraverso qualunque app di messaggistica e non rende il formato impossibile da individuare.

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

Che cosa espone il formato

I marcatori fissi rendono il formato rilevabile. L’illustrazione di copertura è pubblica e non è autenticata in quanto tale; modificarne i bit superiori può lasciare intatto il messaggio incorporato. Correzione degli errori e CRC affrontano i danni di trasporto, mentre AES-GCM autentica il contenuto protetto.

Un attaccante può comunque tentare di indovinare la password offline. Argon2id rende ogni tentativo più costoso, ma non può salvare una password debole. Non è previsto il recupero della password e non viene dichiarato alcun audit di sicurezza indipendente.

Leggere il file senza l’applicazione

Il formato si basa su tecniche crittografiche esistenti, limiti dichiarati e un lettore indipendente. Il lettore per Python 3.12+ supporta i PNG originali, compresi quelli con una copia di recupero JPEG, gli ZIP SnapSeal soggetti a limiti e contenenti un solo PNG, e gli involucri v3 grezzi. Per i file convertiti in JPEG serve invece il codec TypeScript.

Qui è descritta l’implementazione open source v3: i lettori meno recenti già distribuiti potrebbero rifiutare i file che produce. Installa le dipendenze indicate in un ambiente virtuale. Il codice completo e i download facoltativi seguono gli esempi nel testo.

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)