Criptografe arquivos com AES-256-GCM no seu navegador

Criptografar um arquivo com AES-256-GCM no seu navegador é transformar o arquivo em texto cifrado na sua própria máquina, com uma chave derivada de uma senha que você escolhe, antes de o arquivo ir para qualquer lugar: um drive na nuvem, um anexo de e-mail, um pendrive. A criptografia é executada na página, com WebCrypto, e o arquivo e a senha nunca saem do navegador. Isso importa porque um arquivo não é como uma mensagem que você pode digitar de novo: ele é o próprio segredo. Um chat pode descrever o AES-GCM, mas não pode criptografar o seu arquivo real, e colar o arquivo em um chat ou enviá-lo para um site qualquer que diz "criptografar on-line" para que ele o criptografe é entregar o texto claro a um desconhecido. Você pode criptografar e descriptografar arquivos no Criptografador de arquivos, inteiramente no seu navegador, sem limite de tamanho.

Seu arquivo é o segredo: nunca o cole em um chat nem o envie para um site qualquer

As pessoas são cuidadosas com senhas e descuidadas com arquivos, e os arquivos são o vazamento pior. Uma senha pode ser trocada; um arquivo, depois de lido, não pode ser "deslido". Uma declaração de imposto, um rascunho de contrato, uma digitalização de um documento de identidade, uma pasta de fotos de família: cada um carrega informações que continuam sensíveis por anos, e uma vez que uma cópia sai da sua máquina você não pode chamá-la de volta. Essa é a primeira regra deste artigo: nunca cole um arquivo em um chat e nunca o envie para um site cuja única credencial seja dizer "criptografar on-line". O serviço que criptografa o seu arquivo por você viu, por definição, o texto claro. Se ele for invadido, vendido ou simplesmente estiver registrando os envios, a criptografia que ele aplica depois é decoração.

A criptografia local no navegador inverte essa ordem. O arquivo é lido pela página, criptografado bloco a bloco na sua máquina, e só o texto cifrado sai dela: para a sua pasta de downloads e, de lá, para onde você decidir colocá-lo. O site nunca recebe o arquivo, a senha nem a chave, porque não há nenhum servidor para recebê-los: a ferramenta é uma página estática. A mesma lógica explica por que esta ferramenta existe em vez de ser uma resposta de chatbot. Um chatbot pode explicar o AES-GCM perfeitamente e ainda assim não pode criptografar o seu arquivo real, e no momento em que você cola o arquivo para que ele o faça, você entregou o texto claro justamente à parte da qual tentava protegê-lo. Se um fluxo de trabalho precisa do arquivo em si, o trabalho tem de acontecer onde o arquivo já está: na sua máquina.

AES-256-GCM em linguagem simples: uma chave, uma verificação nova em cada bloco

O AES-256-GCM reúne duas garantias em um só algoritmo, e ambas importam para arquivos. A parte "AES-256" é a cifra: uma chave de 256 bits embaralha cada bloco de dados tão profundamente que, com uma chave que ninguém pode adivinhar, o texto cifrado não revela nada do texto claro. A parte "GCM" é a autenticação: para cada bloco do arquivo, o algoritmo calcula uma etiqueta de 16 bytes que é uma impressão digital daquele bloco, da sua posição e da chave. A descriptografia recalcula a etiqueta e a compara; se um único byte mudou — um bit invertido em trânsito, uma senha errada, um bloco trocado com o de outro arquivo — a etiqueta não corresponde e a descriptografia se recusa, em vez de entregar silenciosamente dados corrompidos.

Essa segunda garantia é o motivo pelo qual o GCM supera o modo CBC, mais antigo, para arquivos, e vale a pena entender a diferença. O CBC criptografa cada bloco encadeado ao anterior, mas não tem nenhuma forma integrada de saber se o texto cifrado foi adulterado: um atacante que pode inverter bits em um arquivo CBC pode alterar a saída descriptografada de formas previsíveis, e os clássicos ataques de oráculo de preenchimento contra o CBC exploram exatamente essa fraqueza. Com o CBC você precisa de um HMAC separado para detectar adulteração, e acertar essa construção é onde as implementações erram. O GCM incorpora a verificação: cada bloco carrega a sua própria etiqueta, verificada antes de se confiar no seu texto claro, então não há um segundo mecanismo para acoplar nem preenchimento para atacar. Uma chave, um algoritmo, confidencialidade e autenticação juntas.

Senha ou par de chaves? Quando uma senha compartilhada é a ferramenta certa

Há duas formas honestas de criptografar um arquivo para outra pessoa, e elas resolvem problemas diferentes. Uma senha é um segredo compartilhado: você e o destinatário a combinam — de preferência por outro canal, pessoalmente ou por um meio pelo qual o arquivo em si não viajará — e o arquivo pode ser aberto por qualquer pessoa que a conheça. Um par de chaves, o modelo PGP, é assimétrico: você criptografa com a chave pública do destinatário, só a chave privada dele o abre, e ninguém precisa combinar um segredo antes. O par de chaves vence quando você não pode compartilhar um segredo com segurança, quando o destinatário precisa ser exatamente uma pessoa e quando você quer assinaturas que provem quem enviou o arquivo. Ele perde na configuração: chaves para gerar, guardar, respaldar e revogar, e um destinatário que já precisa ter um par.

A senha vence sempre que o custo de configuração de um par de chaves é o motivo pelo qual a criptografia simplesmente não acontece, o que, para a maioria das pessoas e dos arquivos, é o caso comum. Um arquivo para o seu eu futuro, um backup em um disco em que você não confia totalmente, um documento para um colega a quem você pode entregar a senha pessoalmente: isso não precisa de nenhuma infraestrutura de chaves, só de uma senha forte e de um formato que o destinatário possa abrir. Use o Criptografador de arquivos para esses casos. Quando o destinatário é um desconhecido, quando o arquivo precisa ser atribuível a você ou quando você precisa criptografar para várias pessoas sem compartilhar um segredo entre elas, use o Conjunto PGP: é o mesmo site, a mesma regra de tudo no navegador, e a ferramenta certa para mensagens e identidade. Escolher a ferramenta de senha quando você precisava da de par de chaves é um erro real; escolher a de par de chaves e depois nunca criptografar nada porque a configuração venceu você é o erro mais comum.

Por que outras ferramentas limitam arquivos a 10 MB — e como o streaming remove o limite

Se você já tentou criptografar um arquivo on-line, já encontrou o limite: 10 MB, às vezes menos, e qualquer coisa maior é recusada. O limite não é mesquinhez. A maioria das ferramentas lê o arquivo inteiro na memória, o criptografa de uma só vez, mantém todo o texto cifrado na memória e depois o oferece como download: quatro cópias de um arquivo grande na RAM ao mesmo tempo, além dos limites do próprio navegador sobre o tamanho de um único blob em memória. Um vídeo de 2 GB precisaria de gigabytes de memória para ser criptografado assim, e em uma máquina modesta ele simplesmente falha. Então a ferramenta limita a entrada a um tamanho que ela consegue suportar, e os arquivos grandes ficam sem criptografia.

A solução é parar de segurar o arquivo inteiro de uma vez. O criptografador lê o arquivo em fatias de 1 MiB, criptografa uma fatia, escreve o seu texto cifrado e esquece a fatia antes de ler a próxima: o pico de memória fica perto de um megabyte, não importa o tamanho do arquivo. No Chromium e no Edge, a saída passa pela API de Acesso ao Sistema de Arquivos, então cada bloco criptografado é gravado no disco assim que é produzido: streaming de verdade, sem armazenar o arquivo inteiro em nenhum ponto do processo. O Firefox e o Safari ainda não oferecem essa API, então neles os blocos são reunidos em um download no final: a página diz isso claramente, e para arquivos muito grandes nesses navegadores o conselho honesto é usar um navegador Chromium para o trabalho. O tamanho de bloco de 1 MiB é fixado pelo formato do arquivo, não é uma configuração: é o que o descriptografador espera, e mantê-lo fixo é o que faz com que cada arquivo que esta ferramenta produz seja legível por qualquer outra implementação do formato.

O formato, documentado: seu arquivo não fica preso a este site

Um arquivo criptografado que você não consegue abrir sem o site que o criou é um refém, não um backup. Por isso o formato do contêiner está documentado por completo na página da ferramenta, e esta seção é a versão curta. Um arquivo .sysxenc começa com os oito bytes mágicos SYSXENC1, depois um comprimento de cabeçalho de dois bytes, depois um cabeçalho JSON: a versão do formato, o nome do KDF e a contagem de iterações, um salt aleatório de 16 bytes, o tamanho de bloco de 1 MiB, o nome original do arquivo, o tamanho do texto claro, o SHA-256 do texto claro e um carimbo de data e hora. O corpo é uma sequência de blocos, cada um com um comprimento de texto cifrado de quatro bytes, um IV aleatório novo de 12 bytes e o texto cifrado com a sua etiqueta GCM de 16 bytes. A chave vem da sua senha por meio do PBKDF2-SHA-256 com 600.000 iterações, o número que a OWASP recomenda, e cada bloco é autenticado com dados adicionais que o vinculam a este arquivo e à sua posição: os bytes exatos do cabeçalho mais o índice do bloco, de modo que um bloco reordenado ou enxertado de outro arquivo não passa na verificação da etiqueta.

O sentido de escrever tudo isso é que qualquer pessoa pode implementar um leitor, e o descriptografador em Python abaixo é a prova. Ele usa apenas a biblioteca padrão mais o pacote cryptography, lê o cabeçalho, deriva novamente a chave, descriptografa bloco a bloco verificando cada etiqueta e, por fim, verifica o SHA-256 do texto claro: exatamente o que a ferramenta do navegador faz. Ele foi executado com arquivos produzidos neste formato, incluindo um arquivo de vários megabytes, um arquivo vazio, uma senha errada e um arquivo adulterado, e se comportou corretamente em cada caso. Uma limitação honesta: a linha de comando do OpenSSL não consegue descriptografar este formato em blocos diretamente, porque não tem como expressar os IVs por bloco, os dados autenticados adicionais e as etiquetas. Isso é uma propriedade do design do formato, não um segredo, e este artigo não vai fingir o contrário: use o script abaixo, ou qualquer implementação de AES-GCM.

Os modos de falha: do que a criptografia não pode salvar você

O primeiro modo de falha é o que a ferramenta avisa com mais insistência, porque não tem solução: perdeu a senha e o arquivo se foi. Não há recuperação, não há link de "esqueci minha senha", não há chave-mestra guardada em lugar nenhum: a chave é derivada da sua senha e de nada mais, e sem ela o texto cifrado é indistinguível de bytes aleatórios. Anote a senha em um lugar seguro, separado do arquivo, antes de apagar o original. O segundo modo de falha é uma senha fraca. O PBKDF2 com 600.000 iterações desacelera as tentativas, mas não pode tornar "password123" forte: um atacante que obtém o arquivo pode adivinhar off-line, tão rápido quanto o hardware dele permitir, sem nenhum servidor para bloqueá-lo. Use uma frase longa que você consiga lembrar, não uma senha curta que você consiga digitar rápido.

O terceiro e o quarto modos de falha tratam do que a criptografia não cobre. O cabeçalho guarda o nome original do arquivo, o tamanho e a hora de criação em claro: o conteúdo é secreto, os metadados não. Se o próprio nome do arquivo for sensível, renomeie o arquivo antes de criptografar e considere passá-lo antes pelo Limpador de documentos, já que os documentos carregam os seus próprios metadados por dentro: nomes de autor, histórico de edição, miniaturas embutidas. E nenhuma criptografia ajuda em um dispositivo comprometido. Se a máquina em que você criptografa já estiver executando malware, ela pode ler o arquivo antes da criptografia e a senha enquanto você a digita. A criptografia protege um arquivo em trânsito e em repouso; ela não protege um arquivo em uma máquina que já está sob o controle de outro. Isso não é motivo para pular a criptografia: é o motivo para saber exatamente o que ela compra para você.

Descriptografe um arquivo .sysxenc com Python

#!/usr/bin/env python3
"""Decrypt a SYSXENC v1 file produced by the SysOSX file encryptor.

Format (SYSXENC v1), as documented at
https://www.sysosx.com/tools/file-encryptor/ :
  header: 8-byte magic b"SYSXENC1", u16BE header length, header JSON bytes
          {"v": 1, "kdf": "PBKDF2-SHA256", "iter": 600000,
           "salt": <base64, 16 bytes>, "chunkSize": 1048576,
           "name": <original filename>, "size": <plaintext bytes>,
           "sha256": <hex of plaintext>, "created": <ISO timestamp>}
  body:   chunks, each u32BE ciphertext length (ciphertext INCLUDING the
          16-byte GCM tag) + 12-byte random IV + ciphertext+tag.
          The last chunk may be shorter; an empty file has zero chunks.
  AAD per chunk: the exact header JSON bytes + u32LE chunk index.
  KDF: PBKDF2-HMAC-SHA-256, 600,000 iterations, 256-bit key.

Requires the `cryptography` package:  pip install cryptography

Note: OpenSSL's command-line tool cannot decrypt this chunked format
directly — it has no way to express per-chunk IVs, AAD, and tags — so
use this script (or any AES-GCM implementation) instead.

Usage:
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin --password hunter2
  (without --password, the password is read securely from the terminal)
"""

import argparse
import base64
import getpass
import hashlib
import json
import struct
import sys

MAGIC = b"SYSXENC1"
HEADER_LEN_FMT = ">H"   # u16 big-endian
CHUNK_LEN_FMT = ">I"    # u32 big-endian
CHUNK_INDEX_FMT = "<I"  # u32 little-endian
IV_LEN = 12
TAG_LEN = 16
KEY_LEN = 32


def _read_exact(f, n, what):
    data = f.read(n)
    if len(data) != n:
        raise ValueError(f"truncated file: could not read {what}")
    return data


def decrypt_file(in_path, out_path, password):
    with open(in_path, "rb") as f:
        magic = _read_exact(f, 8, "magic")
        if magic != MAGIC:
            raise ValueError(
                f"bad magic {magic!r}: not a SYSXENC v1 file")
        (header_len,) = struct.unpack(
            HEADER_LEN_FMT, _read_exact(f, 2, "header length"))
        header_bytes = _read_exact(f, header_len, "header JSON")
        header = json.loads(header_bytes.decode("utf-8"))
        if header.get("v") != 1:
            raise ValueError(
                f"unsupported format version: {header.get('v')!r}")
        if header.get("kdf") != "PBKDF2-SHA256":
            raise ValueError(
                f"unsupported KDF: {header.get('kdf')!r}")
        iterations = int(header["iter"])
        salt = base64.b64decode(header["salt"])
        chunk_size = int(header["chunkSize"])
        expected_size = int(header["size"])
        expected_sha256 = header["sha256"]

        key = hashlib.pbkdf2_hmac(
            "sha256", password.encode("utf-8"), salt, iterations, KEY_LEN)

        # Imported here so a bad file fails fast with a format error,
        # not an ImportError.
        from cryptography.hazmat.primitives.ciphers.aead import AESGCM

        aesgcm = AESGCM(key)
        hasher = hashlib.sha256()
        written = 0
        index = 0
        with open(out_path, "wb") as out:
            while True:
                len_bytes = f.read(4)
                if len(len_bytes) == 0:
                    break  # end of body
                if len(len_bytes) != 4:
                    raise ValueError(
                        f"truncated file: chunk {index} length field")
                (ct_len,) = struct.unpack(CHUNK_LEN_FMT, len_bytes)
                iv = _read_exact(f, IV_LEN, f"chunk {index} IV")
                ct_and_tag = _read_exact(
                    f, ct_len, f"chunk {index} ciphertext")
                aad = header_bytes + struct.pack(CHUNK_INDEX_FMT, index)
                try:
                    plain = aesgcm.decrypt(iv, ct_and_tag, aad)
                except Exception as exc:
                    raise ValueError(
                        f"chunk {index} failed authentication: "
                        "wrong password or tampered file") from exc
                out.write(plain)
                hasher.update(plain)
                written += len(plain)
                index += 1

        if written != expected_size:
            raise ValueError(
                f"size mismatch: header says {expected_size} bytes, "
                f"decrypted {written}")
        if hasher.hexdigest() != expected_sha256:
            raise ValueError(
                "SHA-256 mismatch: decrypted content does not match "
                "the header digest (file tampered or corrupt)")
        return header


def main(argv=None):
    parser = argparse.ArgumentParser(
        description="Decrypt a SYSXENC v1 (.sysxenc) file.")
    parser.add_argument("input", help="encrypted .sysxenc file")
    parser.add_argument("output", help="where to write the plaintext")
    parser.add_argument("--password",
                        help="password (if omitted, prompted securely)")
    args = parser.parse_args(argv)
    password = args.password
    if password is None:
        password = getpass.getpass("Password: ")
    try:
        header = decrypt_file(args.input, args.output, password)
    except (ValueError, OSError, KeyError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 1
    print(f"decrypted {header.get('name', args.input)} "
          f"({header['size']} bytes, {header['sha256'][:12]}..., "
          f"SHA-256 verified)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Fontes

Perguntas frequentes

Meu arquivo ou minha senha alguma vez sai do meu navegador?

Não. A criptografia é executada na página usando a API WebCrypto, o arquivo é lido em fatias de 1 MiB na sua máquina e a senha só é usada para derivar a chave localmente. Não há nenhuma etapa de envio, nenhum servidor, nenhuma conta: a ferramenta é uma página estática. A única coisa que sai do navegador é o texto cifrado, quando você o baixa. Se quiser confirmar, abra a aba de rede do seu navegador enquanto criptografa: você não verá nenhuma requisição carregando o arquivo.

O que acontece se eu esquecer a senha?

O arquivo é irrecuperável. A chave é derivada da sua senha pelo PBKDF2 e de nada mais: não há cópia da senha, não há chave de recuperação e o site não tem como redefini-la, porque nunca a vê. Uma senha errada não produz um arquivo corrompido: a descriptografia falha na verificação de autenticação e informa isso, sem gravar nenhuma saída. Guarde a senha em um lugar seguro, separada do arquivo criptografado, antes de apagar o original.

Posso descriptografar um arquivo .sysxenc sem este site?

Sim. O formato SYSXENC v1 está documentado por completo na página da ferramenta: layout do cabeçalho, layout dos blocos, a regra de AAD e os parâmetros do KDF, e o descriptografador em Python deste artigo o implementa com a biblioteca padrão mais o pacote cryptography. Ele foi verificado com arquivos produzidos pela ferramenta. A única coisa que você não pode usar é a linha de comando do OpenSSL: ela não tem como expressar os IVs por bloco, o AAD e as etiquetas, então não consegue descriptografar este formato em blocos diretamente.