在瀏覽器裡用 AES-256-GCM 加密檔案
最後更新:
所謂在瀏覽器裡用 AES-256-GCM 加密檔案,就是在你自己的機器上,用你選的密碼衍生出的金鑰,把檔案變成密文——然後再把它放到雲端硬碟、郵件附件或隨身碟裡。加密在頁面裡用 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 實作。
失效模式:加密救不了你的那些情況
第一個失效模式也是工具警告得最響亮的,因為它沒有任何補救辦法:密碼丟了,檔案就沒了。沒有任何復原,沒有「忘記密碼」連結,也沒有藏在某處的主金鑰——金鑰只由你的密碼衍生,沒有它,密文和隨機位元組沒有區別。在刪除原始檔案之前,先把密碼寫下來,放在一個安全的地方,和檔案分開放。第二個失效模式是弱密碼。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())