Uma mensagem criptografada em uma imagem: por dentro do codec do SnapSeal

Separe o segredo da imagem de capa

O SnapSeal pode proteger imagens, arquivos ou texto. Seu codec criptografa os bytes originais e seus metadados, depois incorpora o envelope resultante em uma imagem de capa. Para decodificar o arquivo protegido, o destinatário precisa da senha, mas não de rede, servidor ou imagem de capa original.

A criptografia preserva a confidencialidade; a esteganografia em imagens fornece o meio de transporte. Nenhuma das duas é uma técnica nova. A demonstração pública usa uma imagem e uma senha de teste publicadas intencionalmente.

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

original.pngcover.webpprotected.png

Use os dois bits menos significativos

Cada pixel RGB tem três canais de 8 bits. Neste exemplo, o codificador percorre os canais da esquerda para a direita, ignora o canal alfa, preserva os seis bits superiores e substitui os dois inferiores. Assim, quatro canais carregam um byte.

Mova o controle para observar a mudança nos bits destacados. Isoladamente, essa gravação altera o valor de um canal em no máximo 3; a cópia opcional para recuperação JPEG e outros tratamentos visuais podem alterar mais a capa.

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

Calcule a capacidade

Três canais com dois bits cada fornecem seis bits por pixel. Uma capa de 1024×1024 comporta 786.432 bytes antes do cabeçalho de 16 bytes do pacote de pixels, restando 786.416 bytes depois dele. Elementos gráficos reservam pixels e reduzem essa capacidade.

Um marcador fixo identifica a estrutura do pacote, e um campo de comprimento delimita o envelope. As versões do pacote e da criptografia são independentes: um pacote PNG2 pode carregar um envelope criptográfico v3.

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

Derive a chave e autentique o envelope

No perfil v3 do SnapSeal, o Argon2id v1.3 deriva uma chave de 32 bytes a partir da senha em UTF-8 e de um salt aleatório de 16 bytes. A derivação usa 64 MiB de memória, três passagens e uma via. Antes de executar a KDF, o leitor deve verificar se os parâmetros fixos de custo são os suportados.

O AES-256-GCM criptografa os bytes originais e os metadados. Sua tag de 16 bytes autentica o conteúdo cifrado e o cabeçalho público de 48 bytes. Se a autenticação falhar, o leitor nunca deve liberar o conteúdo em texto claro.

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)

A mensagem está nos pixels

Os dados ficam nos valores RGB decodificados, não nos metadados do PNG. Dois arquivos PNG podem ter bytes diferentes e ainda preservar a mesma mensagem nos bits inferiores, desde que seus valores RGB decodificados permaneçam iguais. Já uma captura de tela, uma edição de pixels ou um redimensionamento pode destruir os dados sem tornar a imagem irreconhecível.

A menos que a compressão da origem tenha sido selecionada explicitamente, a recuperação restaura os bytes originais e os metadados exatamente. O nome do arquivo é criptografado, mas, sem preenchimento, o envelope ainda revela o tamanho aproximado.

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

Anticompressão: uma segunda via pelo JPEG

A anticompressão é uma tentativa de recuperar o conteúdo de JPEGs que mantenham as mesmas dimensões. O mesmo envelope criptografado tem uma cópia sem perdas nos bits inferiores RGB do PNG e, opcionalmente, uma cópia de recuperação nos coeficientes de frequência da imagem.

Isso não impede a compressão nem promete sobrevivência à passagem por qualquer mensageiro. Também não torna o formato indetectável.

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

Saiba o que o formato expõe

Marcadores fixos tornam o formato detectável. A imagem de capa é pública e não é autenticada como obra visual; alterações em seus bits superiores podem deixar a mensagem incorporada intacta. A correção de erros e o CRC tratam danos de transporte, enquanto o AES-GCM autentica o conteúdo protegido.

Ainda é possível tentar adivinhar senhas offline. O Argon2id encarece cada tentativa, mas não salva uma senha fraca. Não há recuperação de senha, nem alegação de auditoria de segurança independente.

Leia o arquivo sem o aplicativo

O leitor para download em Python 3.12+ aceita PNGs originais, inclusive os que têm uma cópia para recuperação JPEG, ZIPs SnapSeal sujeitos a limites e com um único PNG, e envelopes v3 brutos. Arquivos JPEG convertidos exigem o codec em TypeScript.

O formato descrito aqui corresponde à implementação v3 de código aberto; leitores antigos já publicados podem rejeitar seus arquivos. Instale as dependências indicadas em um ambiente virtual. O código completo e os downloads opcionais vêm depois dos exemplos.

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)