Criptografe arquivos com AES-256-GCM no seu navegador
Última atualização:
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())