Шифруйте файлы с помощью AES-256-GCM в браузере
Последнее обновление:
Зашифровать файл с помощью AES-256-GCM в браузере — значит превратить файл в шифртекст на вашем собственном компьютере, ключом, полученным из выбранного вами пароля, прежде чем файл куда-либо отправится: на облачный диск, во вложение письма, на USB-накопитель. Шифрование выполняется на странице, через WebCrypto, а файл и пароль никогда не покидают браузер. Это важно, потому что файл — не сообщение, которое можно набрать заново: он сам и есть секрет. Чат может описать AES-GCM, но не может зашифровать ваш настоящий файл, а вставив файл в чат или загрузив его на случайный сайт, обещающий «шифрование онлайн», вы сначала отдаёте открытый текст незнакомцу. Шифровать и расшифровывать файлы можно в Шифраторе файлов — полностью в браузере, без ограничения размера.
Ваш файл — это секрет: никогда не вставляйте его в чат и не загружайте на случайный сайт
Люди осторожны с паролями и беспечны с файлами, а файлы — худшая утечка. Пароль можно сменить; файл, однажды прочитанный, нельзя «не прочитать». Налоговая декларация, черновик договора, скан удостоверения личности, папка семейных фотографий — каждый из них несёт информацию, которая остаётся чувствительной годами, и как только копия покидает ваш компьютер, вернуть её нельзя. Таково первое правило этой статьи: никогда не вставляйте файл в чат и никогда не загружайте его на сайт, чьё единственное подтверждение надёжности — фраза «шифрование онлайн». Сервис, который шифрует ваш файл за вас, по определению уже видел открытый текст. Если его взломают, продадут или он просто записывает загрузки, шифрование, которое он применяет потом, — лишь декорация.
Шифрование локально в браузере меняет этот порядок на обратный. Файл читается страницей, шифруется блок за блоком на вашем компьютере, и наружу выходит только шифртекст — в папку загрузок, а оттуда туда, куда вы решите его положить. Сайт никогда не получает ни файл, ни пароль, ни ключ, потому что нет серверной стороны, которая могла бы их получить: инструмент — статическая страница. Та же логика объясняет, почему этот инструмент вообще существует, а не является ответом чат-бота. Чат-бот может идеально объяснить AES-GCM и всё равно не может зашифровать ваш настоящий файл, а в тот момент, когда вы вставляете файл, чтобы он это сделал, вы отдаёте открытый текст именно той стороне, от которой пытались его защитить. Если рабочий процесс нуждается в самом файле, работа должна происходить там, где файл уже находится, — на вашем компьютере.
AES-256-GCM простыми словами: один ключ, новая проверка на каждом блоке
AES-256-GCM объединяет две гарантии в одном алгоритме, и обе важны для файлов. Часть «AES-256» — это шифр: 256-битный ключ перемешивает каждый блок данных настолько основательно, что при ключе, который никто не может угадать, шифртекст ничего не раскрывает об открытом тексте. Часть «GCM» — это аутентификация: для каждого блока файла алгоритм вычисляет 16-байтовый тег — отпечаток этого блока, его позиции и ключа. Расшифровка пересчитывает тег и сравнивает его; если изменился хоть один байт — перевёрнутый бит при передаче, неверный пароль, блок, подменённый блоком из другого файла, — тег не совпадёт, и расшифровка откажется, вместо того чтобы молча выдать вам повреждённые данные.
Вторая гарантия — причина, по которой GCM превосходит старый режим CBC для файлов, и разницу стоит понять. CBC шифрует каждый блок, связывая его с предыдущим, но не имеет встроенного способа узнать, был ли шифртекст подделан: злоумышленник, способный переворачивать биты в CBC-файле, может предсказуемо изменить расшифрованный вывод, и классические атаки padding-oracle против CBC эксплуатируют именно эту слабость. С CBC нужен отдельный HMAC, чтобы обнаружить подделку, и именно в этой конструкции реализации ошибаются. GCM встраивает проверку: каждый блок несёт собственный тег, проверяемый до того, как его открытому тексту поверят, — так что нет ни второго механизма, который нужно приделывать, ни дополнения, которое можно атаковать. Один ключ, один алгоритм, конфиденциальность и аутентификация вместе.
Пароль или пара ключей? Когда общий пароль — правильный инструмент
Есть два честных способа зашифровать файл для другого человека, и они решают разные задачи. Пароль — это общий секрет: вы и получатель договариваетесь о нём — желательно по другому каналу, лично или способом, которым сам файл не пойдёт, — и файл может открыть любой, кто его знает. Пара ключей, модель PGP, асимметрична: вы шифруете открытым ключом получателя, открыть может только его закрытый ключ, и заранее договариваться о секрете никому не нужно. Пара ключей выигрывает, когда вы не можете безопасно поделиться секретом, когда получателем должен быть ровно один человек и когда нужны подписи, доказывающие, кто отправил файл. Она проигрывает в настройке: ключи нужно сгенерировать, хранить, резервировать и отзывать, а у получателя пара уже должна быть.
Пароль выигрывает всякий раз, когда стоимость настройки пары ключей — причина, по которой шифрование вообще не происходит, а для большинства людей и большинства файлов это обычный случай. Файл для себя будущего, резервная копия на диске, которому вы не вполне доверяете, документ коллеге, которому можно передать пароль лично: всё это не требует ключевой инфраструктуры — только надёжный пароль и формат, который получатель сможет открыть. Используйте для этого Шифратор файлов. Когда получатель — незнакомец, когда файл должен быть приписываем вам или когда нужно зашифровать для нескольких людей, не деля между ними один секрет, используйте вместо этого PGP Suite — тот же сайт, то же правило «всё в браузере» и правильный инструмент для сообщений и идентичности. Выбрать инструмент с паролем, когда нужен был инструмент с парой ключей, — настоящая ошибка; но выбрать инструмент с парой ключей и потом так ничего и не зашифровать, потому что настройка вас победила, — ошибка более частая.
Почему другие инструменты ограничивают файлы 10 МБ — и как потоковая обработка снимает ограничение
Если вы когда-нибудь пытались зашифровать файл онлайн, вы встречали ограничение: 10 МБ, иногда меньше, а всё, что больше, отклоняется. Ограничение — не жадность. Большинство инструментов читают весь файл в память, шифруют его за один проход, держат весь шифртекст в памяти, а затем предлагают его скачать: четыре копии большого файла одновременно в оперативной памяти, плюс собственные ограничения браузера на размер одного blob в памяти. Видео на 2 ГБ потребовало бы гигабайты памяти, чтобы зашифровать его таким способом, а на скромном компьютере это просто не сработает. Поэтому инструмент ограничивает ввод размером, который он может пережить, а большие файлы остаются незашифрованными.
Решение — перестать держать весь файл сразу. Шифратор читает файл срезами по 1 МиБ, шифрует один срез, записывает его шифртекст и забывает срез, прежде чем читать следующий: пиковое потребление памяти остаётся около одного мегабайта, каким бы большим ни был файл. В Chromium и Edge вывод идёт через File System Access API, так что каждый зашифрованный блок записывается на диск, как только создан: настоящая потоковая передача, без полной буферизации файла где-либо в конвейере. Firefox и Safari пока не предлагают этот API, поэтому там блоки в конце собираются в одну загрузку — страница говорит об этом прямо, а для очень больших файлов в этих браузерах честный совет — использовать для задачи браузер на Chromium. Размер блока 1 МиБ зафиксирован форматом файла, это не настройка: именно его ожидает расшифровщик, и сохранение его неизменным — то, благодаря чему каждый файл, созданный этим инструментом, читается любой другой реализацией формата.
Формат, документированный: ваш файл не привязан к этому сайту
Зашифрованный файл, который нельзя открыть без сайта, который его создал, — это заложник, а не резервная копия. Поэтому формат контейнера полностью документирован на странице инструмента, а этот раздел — его краткая версия. Файл .sysxenc начинается с восьми магических байтов SYSXENC1, затем двухбайтовая длина заголовка, затем JSON-заголовок: версия формата, имя KDF и число итераций, случайная 16-байтовая соль, размер блока 1 МиБ, исходное имя файла, размер открытого текста, SHA-256 открытого текста и отметка времени. Тело — последовательность блоков, каждый из которых содержит четырёхбайтовую длину шифртекста, свежий случайный 12-байтовый IV и шифртекст с 16-байтовым GCM-тегом. Ключ получается из вашего пароля через PBKDF2-SHA-256 с 600 000 итераций — числом, которое рекомендует OWASP, — а каждый блок аутентифицируется дополнительными данными, привязывающими его к этому файлу и его позиции: точными байтами заголовка плюс индексом блока, так что переставленный блок или блок, вставленный из другого файла, не проходит проверку тега.
Смысл записывать всё это в том, что любой может реализовать читатель, а дешифратор на Python ниже — доказательство. Он использует только стандартную библиотеку плюс пакет cryptography, читает заголовок, заново выводит ключ, расшифровывает блок за блоком, проверяя каждый тег, и в конце сверяет SHA-256 открытого текста — ровно то, что делает инструмент в браузере. Он был запущен на файлах, созданных в этом формате, включая многомегабайтный файл, пустой файл, неверный пароль и подделанный файл, и в каждом случае вёл себя правильно. Одно честное ограничение: командная строка OpenSSL не может расшифровать этот блочный формат напрямую, потому что у неё нет способа выразить IV для каждого блока, дополнительные аутентифицированные данные и теги. Это свойство конструкции формата, а не секрет, и эта статья не будет притворяться иначе — используйте скрипт ниже или любую реализацию AES-GCM.
Режимы отказа: от чего шифрование вас не спасёт
Первый режим отказа — тот, о котором инструмент предупреждает громче всего, потому что исправления для него нет: потеряли пароль — и файл потерян. Нет восстановления, нет ссылки «забыли пароль», нет мастер-ключа, хранящегося где-то: ключ выводится только из вашего пароля, и без него шифртекст неотличим от случайных байтов. Запишите пароль в безопасном месте, отдельно от файла, прежде чем удалять оригинал. Второй режим отказа — слабый пароль. PBKDF2 с 600 000 итераций замедляет перебор, но не может сделать надёжным «password123»: злоумышленник, получивший файл, может перебирать офлайн, так быстро, как позволяет его оборудование, и никакой сервер его не заблокирует. Используйте длинную запоминающуюся парольную фразу, а не короткий пароль, который быстро набирается.
Третий и четвёртый режимы отказа — о том, что шифрование не покрывает. Заголовок хранит в открытом виде исходное имя файла, размер файла и время создания: содержимое секретно, метаданные — нет. Если само имя файла чувствительно, переименуйте файл перед шифрованием и подумайте о том, чтобы сначала прогнать его через Очиститель документов, ведь документы несут собственные метаданные внутри: имена авторов, историю правок, встроенные миниатюры. И никакое шифрование не поможет на скомпрометированном устройстве. Если на компьютере, на котором вы шифруете, уже работает вредоносное ПО, оно может прочитать файл до шифрования и пароль, пока вы его вводите. Шифрование защищает файл при передаче и в покое; оно не защищает файл на компьютере, который уже захвачен. Это не повод пропускать шифрование — это повод точно знать, что оно вам даёт.
Расшифровать файл .sysxenc с помощью 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())