在浏览器里用 AES-256-GCM 加密文件
最后更新:
所谓在浏览器里用 AES-256-GCM 加密文件,就是在你自己的机器上,用你选的密码派生出的密钥,把文件变成密文——然后再把它放到云盘、邮件附件或 U 盘里。加密在页面里用 WebCrypto 运行,文件和密码都不会离开浏览器。这很重要,因为文件不像可以重打一遍的消息:它本身就是机密。聊天工具可以把 AES-GCM 讲得头头是道,却加密不了你真正的文件;而你一旦把文件粘贴进去让它加密,就等于先把明文交给了你本来要防范的那一方。你可以在文件加密器里加密和解密文件,全程在浏览器本地,没有大小上限。
文件本身就是机密——不要把它粘贴进聊天窗口,也不要上传到随便哪个网站
人们对密码很谨慎,对文件却很随意,而文件泄露的后果更严重。密码可以改,文件一旦被人读过就收不回来。一份报税表、一份合同草稿、一张身份证扫描件、一整个文件夹的家庭照片——每一样携带的信息都会敏感很多年,一旦副本离开你的机器,你就再也叫不回来了。这是本文的第一条规则:不要把文件粘贴进聊天窗口,也不要把它上传到任何一个仅凭一句“在线加密”就自称可信的网站。为你加密文件的服务,按定义已经看过明文。如果它被入侵、被出售,或者只是在记录上传内容,之后再做的加密只是装饰。
浏览器本地加密把这个顺序颠倒过来。文件由页面读取,在你的机器上逐块加密,只有密文会离开——先到你的下载文件夹,再由你决定放到哪里。网站收不到文件、密码和密钥,因为根本没有服务端可以接收它们:这个工具就是一个静态页面。同样的道理也解释了为什么这个工具必须存在,而不是变成聊天机器人的一个回答。聊天机器人可以把 AES-GCM 解释得很完美,却加密不了你真正的文件;而你一旦把文件粘贴进去让它动手,你就把明文交给了你本来要防范的那一方。如果某项工作需要用到文件本身,那项工作就必须在文件所在的地方完成——在你的机器上。
用大白话讲 AES-256-GCM:一个密钥,每一块都有新的校验
AES-256-GCM 把两种保证装进了一个算法里,对文件来说两者都很重要。“AES-256”是加密部分:一个 256 位密钥把每一块数据搅得面目全非,只要密钥没人猜得到,密文就不会泄露明文的任何信息。“GCM”是认证部分:对文件的每一块,它都会算出一个 16 字节的标签——这块数据、它的位置和密钥共同决定的指纹。解密时会重新算一遍标签并比对;只要有一个字节被改过——传输中翻转了一位、密码错了、某一块被换成另一个文件的块——标签就对不上,解密会直接拒绝,而不是悄悄给你一份损坏的数据。
第二个保证正是 GCM 胜过老式 CBC 模式的原因,也值得花点时间理解。CBC 把每一块和前一块链在一起加密,但它本身没有办法发现密文是否被篡改:攻击者如果能翻转 CBC 文件里的某些位,就能以可预测的方式改变解密结果,而针对 CBC 的经典填充预言攻击利用的正是这个弱点。用 CBC 时你必须另外加一个 HMAC 来检测篡改,而正是这个拼接步骤最容易出错。GCM 把校验做进了算法里——每一块自带标签,在明文被信任之前先验证——所以不需要再拼一个机制,也没有填充可以攻击。一个密钥、一个算法,机密性和认证同时到手。
密码还是密钥对?什么时候共用密码才是对的工具
为别人加密文件有两种诚实的做法,它们解决的问题不同。密码是一个共用秘密:你和接收方事先约好——最好通过文件本身不会经过的渠道,当面或者另一条信道——知道密码的人都能打开文件。密钥对,也就是 PGP 的模式,是非对称的:你用接收方的公钥加密,只有他的私钥能打开,事先不需要约定任何秘密。密钥对胜在你无法安全地共用秘密时、接收方必须是唯一一个人时,以及你需要签名来证明文件是谁发出的时候。它输在设置成本上:要生成、保管、备份、吊销密钥,接收方还必须事先已经有一对密钥。
密码胜在那些因为密钥对的设置成本而干脆不加密的场合——对大多数人和大多数文件来说,这才是最常见的情况。给未来的自己留一份文件、把备份放在一个你不完全信任的硬盘上、把一份文档交给可以当面递密码的同事:这些都不需要密钥基础设施,只需要一个够强的密码和一个接收方能打开的格式。这些情况用文件加密器。当接收方是陌生人、当文件必须能证明是你发出的,或者当你要加密给几个人而不想让他们共用同一个秘密时,改用PGP 套件——同一个网站、同样是浏览器本地的规则,是消息和身份场景下对的工具。该用密钥对时用了密码工具,是一个真实的错误;但因为设置太麻烦而干脆什么都不加密,是更常见的错误。
为什么别的工具只让传 10 MB——以及流式处理如何去掉这个上限
如果你曾经在网上加密过文件,一定遇到过这个上限:10 MB,有时更小,再大的文件直接拒绝。这个上限不是小气。大多数工具会把整个文件读进内存、一次加密完、把整个密文留在内存里,再提供下载——一个大文件的四份副本同时占着内存,再加上浏览器对单个内存 blob 大小的限制。一个 2 GB 的视频用这种方式加密需要几个 GB 的内存,在配置一般的机器上根本跑不起来。所以工具把输入限制在它能承受的大小,大文件就只能不加密。
解决办法是不要一次握住整个文件。加密器按 1 MiB 一片读取文件,加密一片、写出它的密文、读下一片之前就忘掉这一片——无论文件多大,内存峰值都保持在一兆字节附近。在 Chromium 和 Edge 上,输出走文件系统访问 API,每块密文一产生就直接写进磁盘:真正的流式处理,整个流程里没有任何整文件缓冲。Firefox 和 Safari 目前还没有这个 API,所以在那里,各块会在最后汇总成一次下载——页面会直说这一点,而在这些浏览器上处理非常大的文件时,诚实的建议是换 Chromium 浏览器来做。1 MiB 的块大小由文件格式固定,不是设置项:它是解密方期待的大小,保持固定才能让这个工具产出的每个文件都能被格式的任何其他实现读取。
格式全部公开:你的文件不会被锁在这个网站上
一个没有当初那个网站就打不开的加密文件,不是备份,是人质。所以容器格式在工具页上全文公开,本节是简版。一个 .sysxenc 文件以 8 个魔术字节 SYSXENC1 开头,接着是两字节的头部长度,然后是一段 JSON 头部:格式版本、KDF 名称和迭代次数、一个随机的 16 字节盐、1 MiB 的块大小、原始文件名、明文大小、明文的 SHA-256 和时间戳。正文是一连串的块,每块是四字节密文长度、一个全新的随机 12 字节 IV,以及带 16 字节 GCM 标签的密文。密钥由你的密码经 PBKDF2-SHA-256 派生,迭代 600,000 次——这是 OWASP 推荐的次数——而每一块都用附加数据做认证,把它绑定到这个文件和它的位置:精确的头部字节加上块序号,所以被调换顺序或从另一个文件里拼进来的块都会通不过标签校验。
把这一切都写下来的意义在于,任何人都能实现一个读取器,而下面的 Python 解密器就是证明。它只用标准库加上 cryptography 包,读取头部、重新派生密钥、逐块解密并验证每个标签,最后校验明文的 SHA-256——和浏览器工具做的完全一样。它已经在按这个格式生成的文件上跑过,包括一个几 MB 的多块文件、一个空文件、一个错误的密码和一个被篡改的文件,每种情况的表现都正确。一个诚实的局限:OpenSSL 命令行不能直接解密这种分块格式,因为它没有办法表达每块的 IV、附加认证数据和标签。这是格式设计本身带来的特性,不是秘密,本文也不会假装不是这样——请用下面的脚本,或者任何一个 AES-GCM 实现。
失效模式:加密救不了你的那些情况
第一个失效模式也是工具警告得最响亮的,因为它没有任何补救办法:密码丢了,文件就没了。没有任何恢复,没有“忘记密码”链接,也没有 somewhere 藏着的主密钥——密钥只由你的密码派生,没有它,密文和随机字节没有区别。在删除原文件之前,先把密码写下来,放在一个安全的地方,和文件分开放。第二个失效模式是弱密码。600,000 次迭代的 PBKDF2 能拖慢猜测的速度,但救不了“password123”:攻击者拿到文件后可以离线猜测,按他硬件的速度来,没有任何服务器会把他锁出去。用一个你能记住的长口令,而不是一个打得快的短密码。
第三和第四个失效模式,讲的是加密覆盖不到的地方。头部以明文保存着原始文件名、文件大小和创建时间——内容是保密的,元数据不是。如果文件名本身敏感,加密前先改名;再考虑先过一遍文档清理器,因为文档内部也带着自己的元数据:作者名、编辑历史、内嵌的缩略图。而在已经失陷的设备上,任何加密都帮不上忙。如果加密用的机器上已经跑着恶意软件,它能在加密之前读到文件、在你输入时读到密码。加密保护的是传输中和静止状态的文件,保护不了一台已经被攻陷的机器上的文件。这不是不加密的理由——这是搞清楚加密到底能给你什么的理由。
用 Python 解密 .sysxenc 文件
#!/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())