Salattu viesti kuvan sisällä: SnapSeal-koodekin rakenne

Salaisuus ja sen kantaja

SnapSeal salaa kuvien, tiedostojen tai tekstin alkuperäiset tavut metatietoineen ja upottaa syntyvän salatun säiliön kansikuvaan. Suojatun tiedoston purkamiseen tarvitaan salasana, mutta ei palvelinta eikä alkuperäistä kansikuvaa.

Kryptografia suojaa sisällön luottamuksellisuuden; kuvasteganografia tarjoaa sille kantajan. Kumpikaan menetelmä ei ole uusi. Esimerkin kuvitus ja testisalasana on tarkoituksella julkaistu kaikkien nähtäviksi.

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

original.pngcover.webpprotected.png

Kaksi alinta bittiä käyttöön

Jokaisessa RGB-pikselissä on kolme 8-bittistä kanavaa. Tässä esimerkissä kooderi lukee kanavat vasemmalta oikealle, ohittaa alfa-kanavan ja säilyttää kunkin kanavan kuusi ylintä bittiä. Kaksi alinta se korvaa viestin biteillä. Näin neljään kanavaan mahtuu yksi tavu.

Liikuta liukusäädintä ja seuraa korostettujen bittien muutoksia. Pelkkä alimpien bittien kirjoitus muuttaa kanavan arvoa enintään 3. Valinnainen JPEG-kantaja ja muu kuvan muotoilu voivat muuttaa kansikuvaa enemmänkin.

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

Kuinka paljon kuvaan mahtuu?

Kolme kanavaa ja kaksi bittiä kanavaa kohti antavat kuusi bittiä pikseliä kohden. Kooltaan 1024×1024 olevaan kansikuvaan mahtuu 786 432 tavua ennen 16-tavuista pikselipaketin otsaketta ja 786 416 tavua sen jälkeen. Kuvitus varaa pikseleitä ja pienentää käytettävissä olevaa tilaa.

Kiinteä tunniste kertoo paketin rakenteen, ja pituuskenttä ilmaisee salatun säiliön lopun. Paketin ja salauksen versionumerot kuuluvat eri nimiavaruuksiin: PNG2-paketti voi kuljettaa v3-salaussäiliön.

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

Avaimen johtaminen ja säiliön todennus

SnapSealin v3-profiilissa Argon2id v1.3 johtaa 32-tavuisen avaimen UTF-8-muotoisesta salasanasta ja satunnaisesta 16-tavuisesta suolasta. Laskenta käyttää 64 MiB muistia, kolme kierrosta ja yhtä kaistaa. Lukijan on tarkistettava, että kiinteät työmääräparametrit ovat tuettuja, ennen kuin se käynnistää avaimen johtamisen.

AES-256-GCM salaa alkuperäiset tavut ja metatiedot. Sen 16-tavuinen todennustunniste kattaa salatekstin ja julkisen 48-tavuisen otsakkeen. Jos todennus epäonnistuu, lukija ei saa koskaan luovuttaa selvätekstiä.

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)

Viesti kulkee pikseleissä

Hyötykuorma on puretuissa RGB-arvoissa, ei PNG-metatiedoissa. Kahden PNG-tiedoston tavut voivat erota toisistaan, mutta niissä on silti sama alimpien bittien viesti, jos puretut RGB-arvot ovat muuttumattomat. Kuvakaappaus, pikselien muokkaus tai koon muuttaminen taas voi tuhota datan, vaikka kuva pysyisi tunnistettavana.

Ellei lähteen pakkausta ole erikseen valittu, alkuperäiset tavut ja metatiedot palautuvat täsmälleen. Tiedostonimi on salattu, mutta ilman täytettä säiliö paljastaa sisällön likimääräisen koon.

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

Pakkauksen sieto: toinen reitti JPEG:n läpi

Pakkauksen sieto tarkoittaa yritystä palauttaa viesti JPEG-kuvasta, jonka mitat ovat pysyneet samoina. Samasta salatusta säiliöstä on häviötön kopio PNG:n alimmissa RGB-biteissä ja valinnaisesti palautuskopio kuvan taajuuskertoimissa.

Menetelmä ei estä pakkausta eikä takaa viestin säilymistä mielivaltaisissa viestipalveluissa. Se ei myöskään tee muodosta havaitsematonta.

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ä muoto paljastaa?

Kiinteät tunnisteet tekevät muodosta havaittavan. Kansikuvitus on julkinen, eikä sen aitoutta kuvituksena todenneta; ylempien bittien muutokset voivat jättää upotetun viestin ennalleen. Virheenkorjaus ja CRC käsittelevät siirtovaurioita, kun taas AES-GCM todentaa suojatun sisällön.

Hyökkääjä voi edelleen arvailla salasanoja ilman verkkoyhteyttä. Argon2id tekee jokaisesta yrityksestä kalliimman, mutta ei pelasta heikkoa salasanaa. Salasanaa ei voi palauttaa, eikä tässä väitetä koodekille tehdyn riippumatonta turvallisuusauditointia.

Lukeminen ilman sovellusta

Ladattava Python 3.12+ -lukija tukee alkuperäisiä PNG-kuvia, myös JPEG-palautuskopion sisältäviä PNG-kuvia, kooltaan rajattuja yhden PNG:n SnapSeal-ZIP-tiedostoja sekä raakoja v3-säiliöitä. JPEG-muotoon muunnettujen tiedostojen lukemiseen tarvitaan TypeScript-koodekki.

Tässä kuvataan avoimen lähdekoodin v3-toteutusta; vanhemmat käytössä olevat lukijat voivat hylätä sen tuottamat tiedostot. Asenna ilmoitetut riippuvuudet virtuaaliympäristöön. Koko lähdekoodi ja valinnaiset lataukset ovat artikkelin koodiesimerkkien jälkeen.

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)