Шифруйте файлы с помощью 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())

Источники

Часто задаваемые вопросы

Покидают ли мой файл или пароль когда-нибудь браузер?

Нет. Шифрование выполняется на странице с помощью WebCrypto API, файл читается срезами по 1 МиБ на вашем компьютере, а пароль используется только локально для вывода ключа. Нет шага загрузки, нет серверной стороны, нет учётной записи — инструмент представляет собой статическую страницу. Единственное, что покидает браузер, — это шифртекст, когда вы его скачиваете. Если хотите убедиться, откройте вкладку сети браузера во время шифрования: вы не увидите ни одного запроса, несущего файл.

Что будет, если я забуду пароль?

Файл невосстановим. Ключ выводится из вашего пароля через PBKDF2 и больше ни из чего: нет копии пароля, нет ключа восстановления, и сайт никак не может его сбросить, потому что никогда его не видит. Неверный пароль не даёт повреждённый файл: расшифровка не проходит проверку аутентификации и сообщает об этом, ничего не записывая в вывод. Храните пароль в безопасном месте, отдельно от зашифрованного файла, прежде чем удалять оригинал.

Могу ли я расшифровать файл .sysxenc без этого сайта?

Да. Формат SYSXENC v1 полностью документирован на странице инструмента: расположение заголовка, расположение блоков, правило AAD и параметры KDF, а дешифратор на Python в этой статье реализует его со стандартной библиотекой и пакетом cryptography. Он проверен на файлах, созданных инструментом. Единственное, что вы не можете использовать, — командная строка OpenSSL: у неё нет способа выразить IV для каждого блока, AAD и теги, поэтому она не может расшифровать этот блочный формат напрямую.