Постквантовая криптография и практика безопасного применения

Вся криптография с открытым ключом, разобранная в этом курсе, стоит на двух задачах: факторизации и дискретном логарифме. RSA держится на первой, Диффи — Хеллман и эллиптические кривые — на второй. В 1994 году Питер Шор показал, что квантовый компьютер решает обе за полиномиальное время ¹. Это не ослабило схемы — это поставило под вопрос само их существование.

Симметричная криптография пострадала меньше. Алгоритм Гровера даёт лишь квадратичное ускорение перебора ², поэтому AES-128 превращается в «AES-64», а AES-256 остаётся стойким. Но асимметричная часть — обмен ключами, подписи, сертификаты — ломается целиком, а вместе с ней и вся инфраструктура, которую мы строили пятнадцать тем.

Терминология здесь немного путает. «Постквантовая криптография» — это не криптография на квантовых компьютерах, а схемы, которые работают на обычных машинах и при этом стойки к квантовому противнику. «Квантовая криптография» — другое: распределение ключей по квантовому каналу (QKD), где подслушивание физически обнаруживается. QKD требует специального оборудования и не решает задачу подписи; постквантовые схемы решают обе задачи и работают на существующем железе. Именно поэтому стандартизация пошла по второму пути.

Отсюда и название: постквантовая криптография — это схемы, стойкие против квантового противника, но работающие на обычных компьютерах. После восьми лет конкурса NIST в 2024 году опубликовал три стандарта: ML-KEM для обмена ключами, ML-DSA и SLH-DSA для подписей. На них уже переходят браузеры, а гибридный обмен X25519MLKEM768 стал обычным делом в TLS.

Тема устроена так: сначала квантовая угроза и её реальные масштабы, затем стандарты 2024 года и семейства схем, потом учебная криптография на решётках — LWE и схема Регева с числовым примером, — потом хеш-подписи от Лэмпорта до SLH-DSA. Завершают тему внедрение (гибриды, криптографическая гибкость) и практика: что использовать в 2026 году, какие ошибки встречаются чаще всего и что говорит регуляторика.

Паспорт темы. Нужно знать: темы 15. Освоите: оценивать угрозу Шора и Гровера; описывать ML-KEM, ML-DSA и SLH-DSA; объяснять LWE на учебном примере; строить гибридный обмен и планировать crypto-agility; аудировать криптографический код. Проверяет: ЛР 16. Минимум: разделы 1–4. Углубление: разделы 5–6.

Квантовая угроза

Алгоритм Шора

Задача факторизации и задача дискретного логарифмирования считаются трудными, потому что лучшие известные классические алгоритмы субэкспоненциальны (решето числового поля) или экспоненциальны (ро-метод Полларда для дискретного логарифма). Шор свёл обе к нахождению периода функции — а период квантовый компьютер находит преобразованием Фурье за полиномиальное время ¹.

Конкретно: RSA ломается, потому что из n можно найти p и q; Диффи — Хеллман и ECDH ломаются, потому что из g^a можно найти a; ECDSA и EdDSA ломаются, потому что из открытого ключа восстанавливается закрытый. Устоять не может ни одна схема, чья стойкость сводится к этим задачам.

Важно понимать, чего алгоритм Шора не делает. Он не ломает симметричные шифры, хеш-функции и коды аутентификации. Он не даёт «универсального взлома». Он решает конкретный класс задач, и именно на нём стоит вся асимметричная криптография.

Алгоритм Гровера и симметричная криптография

Гровер даёт квадратичное ускорение поиска в неструктурированном пространстве ²: перебор 2^k вариантов превращается в 2^(k/2). Для симметричных схем это означает, что стойкость в битах делится пополам.

У Гровера есть важное ограничение. Ускорение квадратичное, а параллелизация даёт мало: k параллельных машин сокращают время лишь в √k раз, потому что суммарное число операций не уменьшается. То есть защита от Гровера — это просто удвоение ключа, а не «ещё один алгоритм».

Есть и второе ограничение — квантовые вычисления с коррекцией ошибок. Физические кубиты шумят, и для устойчивой работы нужно много физических кубитов на один логический (обычно сотни или тысячи, в зависимости от кода коррекции). Именно поэтому оценки вроде «20 миллионов физических кубитов» выглядят так внушительно: логических там будет всего несколько тысяч.

Практический вывод прост: удвойте длину симметричного ключа и не беспокойтесь. Никакой «постквантовый AES» не нужен — нужен AES-256 и SHA-384 вместо AES-128 и SHA-256.

Оценки ресурсов и «сохрани сейчас — расшифруй потом»

Квантовый компьютер, способный факторизовать RSA-2048, — это не настольная машина. Оценка Гидни и Экера: около 20 миллионов физических кубитов с шумом и примерно 8 часов работы ⁷. Для RSA-4096 — примерно вдвое больше кубитов. Современные устройства имеют порядка сотен — тысяч физических кубитов и не умеют удерживать когерентность достаточно долго для коррекции ошибок.

Из этого часто делают вывод «ещё не скоро, можно не спешить». Это ошибка, и вот почему.

Во-первых, сроки неизвестны. Оценки «через 15–30 лет» — это оценки, а не гарантии, и они менялись в обе стороны.

Во-вторых, работает атака «сохрани сейчас — расшифруй потом» (harvest now, decrypt later): противник записывает зашифрованный трафик сегодня, а расшифровывает, когда появится компьютер. Если данные должны оставаться секретными 10–20 лет, их уже нельзя защищать схемой, которая завтра сломается.

В-третьих, миграция инфраструктуры занимает годы. Сертификаты, прошивки, библиотеки, стандарты, аудит — всё это не обновляется по команде. Отсюда «теорема Москы»: если данные должны быть защищены X лет, а миграция занимает Y лет, начинать нужно за X − Y лет до появления компьютера.

Стандарты 2024 года

Хронология конкурса

NIST начал процесс в 2016 году, объявив конкурс на постквантовые схемы. На первый раунд пришло 82 заявки; после нескольких лет публичного криптоанализа осталось несколько семейств. В июле 2022 года были выбраны Kyber (обмен ключами), Dilithium и Falcon (подписи), SPHINCS+ (подписи на хешах). В августе 2024 года вышли стандарты:

• FIPS 203 — ML-KEM (на основе Kyber) ³;
• FIPS 204 — ML-DSA (на основе Dilithium) ⁴;
• FIPS 205 — SLH-DSA (на основе SPHINCS+) ⁵.

Falcon остался в резерве: он компактнее по подписям, но сложнее в реализации и хуже поддаётся защите от побочных каналов. Обзор всего поля с объяснением, почему именно решётки оказались практичным выбором, дан в статье Бернстайна и Ланге ¹¹.

Отдельно стоит сказать про то, как читать эти стандарты. FIPS 203–205 — не «описания идей», а точные спецификации: в них зафиксированы распределения, порядок операций, правила кодирования и проверки, от которых зависит стойкость. Реализация «по мотивам статьи» почти наверняка будет содержать уязвимость, потому что все тонкости — в деталях, а не в формуле.

ML-KEM

ML-KEM — схема инкапсуляции ключа (KEM): одна сторона генерирует пару ключей, другая инкапсулирует в открытый ключ случайный секрет и отправляет шифртекст, первая декапсулирует. Это замена ECDH: результат — общий секрет 32 байта, из которого выводятся ключи.

Основа — Module-LWE: задача о поиске секрета в системе линейных уравнений над кольцом с малым шумом. Параметры трёх уровней:

Открытый ключ в 1184 байта — это в 37 раз больше, чем 32 байта X25519, и в 2,8 раза больше, чем весь открытый ключ RSA-3072. Отсюда и главная проблема внедрения: трафик рукопожатия растёт.

ML-DSA и SLH-DSA

ML-DSA — подпись на Module-LWE (точнее, на задаче SIS — коротких векторов в решётке). Она даёт подписи в тысячи байт:

SLH-DSA — подпись на хеш-функциях, без всякой алгебры. Она медленнее и даёт огромные подписи (около 7,9 КБ для 128-битного уровня), но её стойкость опирается только на свойства хеша. Это страховка: если решёточные схемы когда-нибудь сломают, останется вариант, не зависящий от их математики.

Сравним с привычным:

Семейства схем и взлом SIKE

Постквантовая криптография — не одна схема, а несколько семейств с разной математикой.

• Решётки. ML-KEM, ML-DSA, Falcon. Быстрые, компактные ключи, но требуют аккуратной реализации (постоянное время, защита от утечек).
• Коды. Classic McEliece — схема 1978 года, стойкая до сих пор, с открытым ключом в сотни килобайт и шифртекстом в сотню байт. Ключ огромен, зато передаётся один раз и дальше не мешает; в сценариях «ключ в прошивке» это приемлемо, с огромным открытым ключом (сотни килобайт) и крошечным шифртекстом. Хороша для случаев, когда ключ передаётся один раз.
• Хеш-подписи. Лэмпорт, Меркл, XMSS, LMS, SLH-DSA. Стойкость опирается только на хеш; цена — размер и скорость.
• Изогении. SIKE — красивая схема на изогениях эллиптических кривых, дошедшая до финала конкурса. В 2022 году Кастрик и Декрю нашли атаку, восстанавливающую ключ за минуты на одном ядре ⁸. Схему исключили.

У каждого семейства своя ниша. Решётки удобны везде, где важны размеры и скорость. Коды — там, где ключ статичен, а канал узкий. Хеш-подписи — там, где нужна максимальная уверенность в предположениях и можно пожертвовать размером: прошивки, обновления, долгоживущие документы.

История SIKE — важный урок. Схема прошла несколько лет публичного анализа, была финалистом и всё равно оказалась сломана. Это не значит, что решётки тоже сломают; это значит, что «прошло пять лет аудита» не равно «безопасно». Отсюда и стратегия NIST: несколько семейств параллельно плюс гибриды.

Учебная криптография на решётках

LWE своими словами

Задача Learning With Errors (LWE), предложенная Регевом в 2005 году ⁶, формулируется так. Есть секретный вектор s из n малых чисел. Противнику даны m уравнений вида

b_i = a_i · s + e_i  (mod q)

где a_i — случайные векторы, а e_i — маленькие ошибки. Нужно найти s.

Без ошибок это обычная система линейных уравнений: гауссово исключение, и всё. Именно ошибки делают задачу трудной: каждое уравнение «почти верно», но неизвестно, насколько именно. Интуиция такая: вы знаете, что точки лежат почти на гиперплоскости, но не знаете, в какую сторону и насколько они сдвинуты, — и при большой размерности это неразрешимо.

У задачи есть важное свойство: она «худший случай — средний случай». Регев доказал, что если LWE трудна в среднем, то она трудна и в худшем случае (для решёточных задач), — а это означает, что криптографу не нужно искать «удачные» экземпляры: подойдёт любой. Классические схемы такого свойства не имеют, и именно оно делает LWE удобной основой стандартов.

Стойкость LWE связана с трудными задачами в решётках (приближённое кратчайшее независимое семейство векторов), и лучшие известные алгоритмы работают экспоненциально по n. Это и есть причина, по которой на LWE строят постквантовые схемы: алгоритм Шора здесь не помогает, потому что задача не сводится к поиску периода.

Схема Регева

Простейшее шифрование на LWE — схема Регева для одного бита.

ключи:   s ← {−1,0,1}^n ;  A ← случайная m×n ;  e ← {−1,0,1}^m
         b = A·s + e (mod q) ;  открытый ключ (A, b), секрет s
шифр:    выбрать случайное подмножество S из m уравнений
         u = Σ_{i∈S} A_i ,  v = Σ_{i∈S} b_i + bit·(q/2)  (mod q)
расшифр: d = v − s·u (mod q)
         d ближе к 0 → бит 0 ;  d ближе к q/2 → бит 1

Почему это работает: v − s·u = Σ e_i + bit·(q/2). Сумма ошибок мала по сравнению с q/2, поэтому результат остаётся рядом с нулём или рядом с q/2, и бит восстанавливается. Стойкость держится на том, что по (A, b) найти s трудно.

Совсем маленький пример, который можно проверить вручную. Возьмём n = 3, q = 97, m = 4, секрет s = (1, −1, 0), ошибки e = (−1, −1, 0, 0). Тогда

A = [[57, 71, 59],        b = A·s + e = (82, 88, 1, 77)
     [57, 65, 75],
     [24, 23, 65],
     [60, 80, 78]]

Шифруем бит 1, выбирая подмножество уравнений {1, 3, 4} (нумерация с единицы): u = (44, 77, 8), v = b₁ + b₃ + b₄ + 48 = 14 (mod 97). Расшифрование: d = v − s·u = 14 − (44 − 77) = 47. Это ближе к q/2 = 48, чем к нулю, значит бит — 1. Всё сошлось, и видно, откуда взялось 47: это сумма ошибок (−1 + 0 + 0) плюс сдвиг 48.

Числовой пример с параметрами из лабораторной работы (n = 8, q = 97, m = 16):

• секрет s — восемь чисел из {−1, 0, 1};
• каждое уравнение добавляет ошибку ±1 или 0;
• сумма шестнадцати ошибок не превышает 16, а порог — q/4 = 24;
• значит, расшифрование ошибается только если сумма ошибок превысит 24, что при таких параметрах случается редко.

Код шифрования и расшифрования занимает десяток строк:

def encrypt(pk, bit, params, rng):
    A, b = pk
    q, n, m = params["q"], params["n"], params["m"]
    mask = [rng.randrange(2) for _ in range(m)]
    u = [sum(mask[i] * A[i][j] for i in range(m)) % q for j in range(n)]
    v = (sum(mask[i] * b[i] for i in range(m)) + bit * (q // 2)) % q
    return u, v

def decrypt(secret, ciphertext, params):
    q, n = params["q"], params["n"]
    u, v = ciphertext
    d = (v - sum(secret[j] * u[j] for j in range(n))) % q
    return 0 if min(d, q - d) <= q // 4 else 1

Сравните с тем, что делает ML-KEM: те же u и v, только над кольцом многочленов, с хешами и отбраковкой. Принцип один.

Почему без шума всё ломается

Если убрать ошибки, шифрование Регева становится прозрачным: b = A·s — обычная линейная система, и s находится методом Гаусса за O(n³). Лабораторная работа показывает это буквально: функция recover_secret_noiseless решает систему над GF(97) и восстанавливает секрет, а при добавлении шума система становится несовместной, и метод Гаусса даёт либо ошибку, либо неверный ответ.

Это не курьёз, а суть конструкции: шум — единственное, что защищает схему. Отсюда и требования к реализации ML-KEM: распределение шума должно быть ровно таким, как в стандарте, а отбраковка (проверка, что шифртекст не деградировал) — обязательной. Ошибка в генерации шума или в проверке приводит к атакам, которых в спецификации нет.

Почему нельзя выбрать параметры самому

Параметры ML-KEM — не предмет вкуса. От них зависит и стойкость, и вероятность ошибки расшифрования, и эти две величины тянут в разные стороны: больше шум — выше стойкость и выше вероятность сбоя; меньше шум — наоборот. Стандарт фиксирует компромисс, при котором вероятность ошибки меньше 2^-128, а стойкость соответствует уровню NIST.

Если уменьшить шум «чтобы не было ошибок», схема ослабнет. Если увеличить размерность «чтобы надёжнее», вырастут ключи и упадёт скорость. Если поменять распределение на более удобное — изменится доказательство стойкости, и схема перестанет быть ML-KEM. Это ровно тот случай, когда «самодельные параметры» — не оптимизация, а уязвимость.

От LWE к ML-KEM

ML-KEM устроен сложнее учебной схемы, но идея та же.

• Вместо произвольной матрицы — кольцо многочленов Z_q[X]/(X^256 + 1), и умножение делается через NTT. Это даёт скорость и компактность.
• Вместо одного вектора — модуль ранга k (отсюда «Module-LWE»): k = 2, 3, 4 для трёх уровней.
• Добавлены хеши и «отбраковка» (FO-преобразование), чтобы схема была стойкой в модели с выбором шифртекста, а не только в пассивной модели.
• Секрет и шум — из центрированного биномиального распределения, а не из {−1,0,1}.

Стоит сразу ответить на частый вопрос: зачем гибрид, если ML-KEM уже стандартизован? Причин две. Первая — доверие: решёточные схемы моложе, чем RSA и ECC, и публичный анализ продолжается. Вторая — совместимость: гибрид позволяет включить постквантовую защиту, не отказываясь от привычной, и не требует менять сертификаты. Если завтра найдётся атака на ML-KEM, гибрид останется стойким на X25519; если появится квантовый компьютер, гибрид останется стойким на ML-KEM. Такая «страховка с двух сторон» и есть смысл конструкции.

Именно эти детали — предмет стандарта. Учебная схема показывает принцип, но не заменяет FIPS 203: реализовывать ML-KEM самостоятельно нельзя ни при каких обстоятельствах.

Хеш-подписи

Лэмпорт

Одноразовая подпись Лэмпорта предложена в 1979 году ⁹ и устроена настолько просто, что её можно объяснить за минуту.

ключи:  для каждого из 256 бит — пара секретов sk[i][0], sk[i][1]
        открытый ключ: pk[i][b] = H(sk[i][b])
подпись: для каждого бита дайджеста d[i] раскрыть sk[i][d[i]]
проверка: для каждого i проверить H(sig[i]) == pk[i][d[i]]

Стойкость следует из односторонности хеша: зная H(x), нельзя найти x. Подделка подписи требует найти прообраз — то есть сломать хеш.

Цена — размер. Для 256-битного дайджеста открытый ключ и секрет занимают по 16 КБ (256 пар по 32 байта), а подпись — 8 КБ. И главное: подпись одноразовая. Две подписи разными сообщениями раскрывают секреты для всех битов, где дайджесты различаются, — а в среднем это половина битов. После этого подделать подпись любого сообщения несложно.

Меркл и XMSS/LMS

Меркл в 1989 году предложил решение ¹⁰: сгенерировать много одноразовых ключей, построить над ними дерево Меркла и опубликовать только корень. Подпись тогда состоит из одноразовой подписи и пути в дереве.

Для восьми ключей путь — три хеша по 32 байта, то есть 96 байт дополнительно. Для 2^20 ключей — уже 20 хешей, 640 байт, зато одноразовых подписей хватает надолго. Схемы XMSS и LMS стандартизованы и используются там, где нужна стойкость без алгебраических предположений: в прошивках, в подписи обновлений, в долгоживущих системах.

Главная практическая опасность XMSS и LMS — состояние. Каждая подпись использует одноразовый лист, и номер использованного листа нужно хранить. Если восстановить подписывающую машину из резервной копии и подписать ещё раз тем же листом, получится ровно та же катастрофа, что и при повторе nonce в ECDSA (тема 13): два разных сообщения с одним одноразовым ключом раскрывают ключ.

Полезно посчитать. Для 2^20 подписей дерево Меркла требует хранить 2^21 узлов, то есть около 64 МБ хешей, и время генерации ключа — минуты. Для 2^10 подписей это уже 64 КБ и секунды. Отсюда практика: либо дерево на миллион подписей с офлайн-генерацией, либо иерархия из деревьев поменьше.

Ограничение остаётся: число подписей фиксировано заранее. Исчерпали дерево — нужен новый открытый ключ. Отсюда практика: либо дерево на миллионы подписей, либо иерархия деревьев.

SLH-DSA

SLH-DSA (FIPS 205 ⁵) — стандартизованный вариант SPHINCS+, то есть хеш-подпись с деревом и «немного Stateless»: подписывающий не хранит состояние между подписями. Это важно: XMSS и LMS требуют хранить счётчик использованных листьев, и его потеря (восстановление из резервной копии) означает повторное использование одноразового ключа — катастрофу.

Проверка хеш-подписи дешевле подписания: нужно пересчитать хеши по пути и сравнить с корнем. Подписание дороже, потому что требует построить путь и, в случае stateless-схемы, пройти несколько уровней дерева. Для сервера, который подписывает редко, а проверяет часто, это удобно; для устройства, которое подписывает постоянно, — не очень.

SLH-DSA решает проблему состояния ценой размера и скорости: подпись 7856 байт, подписание — миллисекунды-секунды. Зато стойкость опирается только на хеш-функцию, а состояние не нужно вовсе.

Внедрение: гибриды и гибкость

X25519MLKEM768

Гибридный обмен — компромисс между «уже можно» и «ещё страшно». Идея: выполнить два обмена одновременно, классический и постквантовый, и скомбинировать секреты через KDF. Стойкость сохраняется, если не сломан хотя бы один из компонентов.

Как именно комбинируются секреты? Не сложением и не «взять первый». Стандартный приём — конкатенация и KDF: secret = HKDF(X25519-секрет ‖ ML-KEM-секрет, context). Такая конструкция сохраняет стойкость, если хотя бы один из входов случаен и неизвестен противнику, — а второй при этом может быть полностью скомпрометирован. Если бы секреты складывали побитово, компрометация одного давала бы знание разности и ослабляла другой.

Отдельный вопрос — аутентификация. Гибридный обмен защищает от пассивного противника с квантовым компьютером, но подпись сервера всё ещё классическая. Значит, активный противник с квантовым компьютером теоретически может подделать подпись и встать посередине. Именно поэтому стандарты предусматривают и гибридные подписи: ML-DSA вместе с Ed25519.

В TLS 1.3 это просто ещё одна группа: X25519MLKEM768. Клиент присылает key_share, содержащий и X25519-ключ, и ML-KEM-768-ключ; сервер отвечает тем же; общий секрет — результат комбинирования.

Поддержка зависит от версии: ML-KEM появился в OpenSSL 3.5, а гибридные группы — там же. Проверим, что есть в системе, и посмотрим на размеры ключей.

openssl list -kem-algorithms | grep -i ml-kem
openssl genpkey -algorithm ML-KEM-768 -out mlkem.pem
openssl pkey -in mlkem.pem -pubout -outform DER | wc -c

В OpenSSL 3.6 вывод первой команды содержит ML-KEM-512, ML-KEM-768, ML-KEM-1024 и гибриды X25519MLKEM768, X448MLKEM1024, SecP256r1MLKEM768. Вторая и третья команды дают открытый ключ ML-KEM-768 размером 1206 байт в DER (1184 байта чистого ключа плюс заголовок).

Цена видна в размерах.

openssl s_client -connect 127.0.0.1:8443 -tls1_3 -groups X25519 -msg
openssl s_client -connect 127.0.0.1:8443 -tls1_3 -groups X25519MLKEM768 -msg

Обе команды требуют OpenSSL 3.5 или новее; на 3.0 вторая завершится ошибкой «неизвестная группа», и это ожидаемо. Разница в размере ClientHello — 221 байт против 1399 байт для гибрида. Эти 1178 байт почти ровно равны открытому ключу ML-KEM-768 (1184 байта), и именно они определяют цену гибрида для сети.

Что зависит от версии, а что нет

Постквантовая часть меняется быстрее остального курса, поэтому полезно отделять устойчивые сведения от преходящих. Ниже — граница, которую стоит держать в голове при чтении любых материалов по теме.

Правило простое: если утверждение содержит номер версии или слово «по умолчанию», оно проверяется командой openssl version или python3 -c "import cryptography; print(cryptography.__version__)" перед тем, как попасть в отчёт. Если версия не совпадает с ожидаемой, это фиксируется одной строкой, а не подгоняется под текст.

С подписями ситуация сложнее. Сертификат с ML-DSA-65 добавляет к цепочке около двух килобайт вместо 91 байта у P-256, а подпись в CertificateVerify — ещё 3,3 КБ. Для одной цепочки из трёх сертификатов это уже десяток килобайт, и часть старых клиентов просто не примет такой ClientHello/Certificate. Поэтому внедрение подписей идёт медленнее, чем обмена ключами: обмен можно сделать гибридным незаметно, а подпись видна всем.

На практике это означает, что рукопожатие вырастает на один-два пакета и что часть старых устройств может упереться в MTU. Браузеры и крупные CDN включают гибрид по умолчанию, а серверы постепенно догоняют.

Криптографическая гибкость и инвентаризация

Crypto-agility — способность системы менять алгоритмы без переделки архитектуры. Звучит просто, но на практике всё упирается в инвентаризацию: нужно знать, где и какие алгоритмы используются.

Минимальный план перехода выглядит так.

1. Инвентаризация. Собрать все места, где есть криптография: TLS, подписи кода, сертификаты, шифрование данных, токены, прошивки. Для каждого — алгоритм, длина ключа, срок жизни данных.
2. Приоритизация. Сначала — долгоживущие данные и долгоживущие ключи: то, что переживёт появление компьютера.
3. Гибриды. Включить гибридный обмен там, где поддержка уже есть, — это дешёвый шаг без изменения архитектуры.
4. Готовность к смене подписи. Проверить, что формат сертификатов и подписей допускает новые алгоритмы (это не всегда так: старые форматы фиксируют OID).
5. Мониторинг. Отслеживать, какие алгоритмы реально используются, а не какие заявлены в конфигурации.

Моска сформулировал это как правило: срок защиты данных плюс срок миграции должны укладываться в срок до появления компьютера ¹⁴. NIST в IR 8547 уточняет план: устаревшие алгоритмы объявляются deprecated, затем disallowed, и переход растянут на годы ¹².

Практика безопасного применения

Что использовать в 2026 году

Сводная таблица по всему курсу — то, что стоит помнить, если из головы выветрится всё остальное.

Хорошая библиотека экономит не строки, а решения. Сравните два подхода к одной задаче — зашифровать сообщение с аутентификацией.

# высокоуровневый вариант: всё уже собрано правильно
from cryptography.fernet import Fernet

key = Fernet.generate_key()
token = Fernet(key).encrypt(b"secret")
assert Fernet(key).decrypt(token) == b"secret"

# низкоуровневый вариант: AES-GCM, IV и тег — на вашей совести
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = AESGCM.generate_key(bit_length=256)
iv = os.urandom(12)
ct = AESGCM(key).encrypt(iv, b"secret", b"aad")
assert AESGCM(key).decrypt(iv, ct, b"aad") == b"secret"

Fernet — это AES-CBC с HMAC, версией формата и меткой времени, собранный так, чтобы неправильно использовать его было трудно. AES-GCM даёт больше свободы и больше способов ошибиться: забыть AAD, переиспользовать IV, не проверить тег. Правило простое: если высокоуровневый API решает задачу — берите его.

Таблица — ориентир, а не догма: в регулируемой среде могут требоваться ГОСТ-алгоритмы, а в унаследованной системе — поддерживать то, что уже есть. Но отклонение должно быть осознанным и задокументированным.

Типичные ошибки и CWE

Классификация помогает не повторять чужие ошибки. Ниже — то, что встречается в учебном коде чаще всего ¹³.

Лабораторная работа даёт модуль с десятью такими ошибками — их нужно найти, классифицировать и исправить. Это самое полезное упражнение курса: узнать ошибку в чужом коде проще, чем не допустить её в своём.

Управление секретами

Секреты в коде — отдельная категория, потому что они не «ошибка алгоритма», а ошибка процесса. Правила простые.

• Секрет живёт в хранилище секретов (KMS, Vault, переменные окружения), а не в исходниках и не в git.
• У каждого секрета есть владелец, срок жизни и процедура ротации.
• Секрет, попавший в репозиторий, считается скомпрометированным, даже если коммит удалён: история есть у всех.
• Логи не содержат секретов и ключей; отладочные дампы — тоже.
• Резервные копии ключей защищены так же, как сами ключи.

Отдельная тема — зависимости. Криптографическая ошибка часто приходит не из своего кода, а из библиотеки: устаревший OpenSSL, самодельная обёртка над cryptography, «свой» парсер сертификатов. Инвентаризация зависимостей и отслеживание CVE — часть гигиены, а не бюрократия. Хорошая практика: минимум зависимостей, фиксация версий, автоматическое обновление с тестами.

И ещё одна тонкость: постоянное время. Сравнение MAC, проверка дополнения, разбор токена — всё это не должно зависеть от секретных данных по времени выполнения. В Python для этого есть hmac.compare_digest, в C — свои приёмы, но главное — не писать if token == expected.

Регуляторика

В России применение криптографии регулируется: для защиты информации в государственных системах и для квалифицированных подписей используются сертифицированные средства криптографической защиты информации (СКЗИ), чаще всего на алгоритмах ГОСТ. ГОСТ Р 34.10-2012 и ГОСТ Р 34.11-2012 — это подпись и хеш; ГОСТ Р 34.12-2015 — блочный шифр («Кузнечик», «Магма»).

Есть и более общий принцип: регуляторика отвечает на вопрос «можно ли применять», а не «безопасно ли это». Сертификат соответствия не заменяет анализ угроз, а анализ угроз не заменяет сертификат. В проекте нужны оба, и лучше, если они не противоречат друг другу.

Практические следствия:

• для квалифицированной электронной подписи нужен аккредитованный УЦ и сертифицированное СКЗИ (тема 14);
• для государственных информационных систем — требования ФСТЭК и ФСБ, включая классы защиты;
• для TLS с ГОСТ-алгоритмами нужны сертифицированные реализации; в общем случае это отдельный стек, а не «OpenSSL с другой кривой»;
• для коммерческих систем вне регулируемой сферы ограничений на алгоритмы нет, но контрагент может требовать ГОСТ по договору.

Отдельно стоит помнить: сертификация — это про соответствие требованиям, а не про отсутствие уязвимостей. Сертифицированное СКЗИ может иметь ошибку в парсинге; несертифицированная библиотека может быть безупречна. Это разные оси.

Итоги темы

Квантовый компьютер ломает асимметричную криптографию алгоритмом Шора и вдвое ослабляет симметричную алгоритмом Гровера. Оценки ресурсов велики (миллионы кубитов и часы работы для RSA-2048), но угроза «сохрани сейчас — расшифруй потом» делает ожидание опасным: данные, перехваченные сегодня, могут быть расшифрованы позже.

Стандарты 2024 года дают готовые замены: ML-KEM для обмена ключами, ML-DSA и SLH-DSA для подписей. Решёточные схемы компактнее и быстрее, хеш-подписи надёжнее по предположениям, коды дают крошечные шифртексты при огромных ключах. Взлом SIKE напоминает, что публичный анализ не гарантирует стойкости, и потому стандартов несколько.

Учебная криптография на решётках показывает суть: LWE — это система линейных уравнений с малым шумом, и весь секрет в шуме. Без шума она решается методом Гаусса; с шумом — нет. Хеш-подписи идут другим путём: Лэмпорт даёт одноразовую подпись из односторонней функции, дерево Меркла превращает её в многократную, SLH-DSA убирает состояние ценой размера.

Внедрение идёт через гибриды: X25519MLKEM768 в TLS добавляет около килобайта к рукопожатию и сохраняет стойкость, пока не сломан хотя бы один компонент. Криптографическая гибкость и инвентаризация — не бюрократия, а условие перехода.

И последнее, что важнее всех алгоритмов: безопасность определяется не выбором «самой стойкой схемы», а дисциплиной. Постоянное время, случайность из правильного источника, секреты вне кода, проверка целостности, аккуратная обработка ошибок. Список CWE в этой теме — по сути, чек-лист того, что ломается в реальных системах чаще, чем любая математика.

Литература

1. Shor P. W. Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer. — SIAM Journal on Computing, 1997, Т. 26, № 5, С. 1484–1509. DOI: 10.1137/S0097539795293172
2. Grover L. K. A Fast Quantum Mechanical Algorithm for Database Search. — Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC), 1996, С. 212–219. DOI: 10.1145/237814.237866
3. NIST. Module-Lattice-Based Key-Encapsulation Mechanism Standard. — FIPS 203, 2024. DOI: 10.6028/NIST.FIPS.203
4. NIST. Module-Lattice-Based Digital Signature Standard. — FIPS 204, 2024. DOI: 10.6028/NIST.FIPS.204
5. NIST. Stateless Hash-Based Digital Signature Standard. — FIPS 205, 2024. DOI: 10.6028/NIST.FIPS.205
6. Regev O. On Lattices, Learning with Errors, Random Linear Codes, and Cryptography. — Journal of the ACM, 2009, Т. 56, № 6, С. 1–40. DOI: 10.1145/1568318.1568324
7. Gidney C., Ekerå M. How to Factor 2048 Bit RSA Integers in 8 Hours Using 20 Million Noisy Qubits. — Quantum, 2021, Т. 5, С. 433. DOI: 10.22331/q-2021-04-15-433
8. Castryck W., Decru T. An Efficient Key Recovery Attack on SIDH. — Advances in Cryptology — EUROCRYPT 2023, Springer, 2023, С. 423–447. DOI: 10.1007/978-3-031-30589-4_15
9. Lamport L. Constructing Digital Signatures from a One-Way Function. — Technical Report CSL-98, SRI International, 1979.
10. Merkle R. C. A Certified Digital Signature. — Advances in Cryptology — CRYPTO '89, Springer, 1990, С. 218–238. DOI: 10.1007/0-387-34805-0_21
11. Bernstein D. J., Lange T. Post-Quantum Cryptography. — Nature, 2017, Т. 549, С. 188–194. DOI: 10.1038/nature23461
12. NIST. Transition to Post-Quantum Cryptography Standards. — NIST IR 8547 (initial public draft), 2024. DOI: 10.6028/NIST.IR.8547.ipd
13. MITRE. Common Weakness Enumeration (CWE). — https://cwe.mitre.org
14. Mosca M. Cybersecurity in an Era with Quantum Computers: Will We Be Ready? — IEEE Security & Privacy, 2018, Т. 16, № 5, С. 38–41. DOI: 10.1109/MSP.2018.3761723

Тема 16. Дополнительные материалы

Вопросы для самопроверки

1. Что именно ломает алгоритм Шора? Факторизацию и дискретный логарифм — обе задачи сводятся к поиску периода функции. Все схемы, чья стойкость на них держится, ломаются целиком.
2. Что делает Гровер? Даёт квадратичное ускорение перебора: 2^k превращается в 2^(k/2). Поэтому AES-128 становится «AES-64», а AES-256 — «AES-128».
3. Почему параллельные квантовые компьютеры не спасают от Гровера? Суммарное число операций не уменьшается, поэтому k машин дают ускорение лишь в √k раз.
4. Почему «сохрани сейчас — расшифруй потом» важнее сроков? Данные, перехваченные сегодня, будут расшифрованы позже; если они должны оставаться секретными 15 лет, защита нужна уже сейчас.
5. Чем KEM отличается от обмена ключами? В KEM одна сторона генерирует пару ключей, другая инкапсулирует секрет и отправляет шифртекст; в DH обе стороны присылают открытые значения. Интерфейс разный, результат — общий секрет.
6. Почему ML-KEM не заменяет X25519 сразу? Ключи и шифртексты в десятки раз больше, а публичный анализ короче. Гибрид позволяет включить защиту, не отказываясь от проверенной схемы.
7. Почему подпись Лэмпорта одноразовая? Каждая подпись раскрывает по одному секрету из пары; вторая подпись с другим дайджестом раскрывает оставшиеся — и позволяет подделать подпись любого сообщения.
8. Как работает дерево Меркла? Листья — хеши открытых ключей, узлы — хеши пар, корень публикуется. Подпись включает путь от листа до корня длиной log₂ N.
9. Почему SLH-DSA не требует состояния? Вместо одного большого дерева с фиксированным счётчиком используется иерархия деревьев, выбираемых хешем сообщения, — лист не нужно запоминать.
10. В чём суть LWE? Дана система линейных уравнений с малым шумом; нужно найти секрет. Без шума — метод Гаусса, с шумом — экспоненциально трудная задача.
11. Почему нельзя менять параметры ML-KEM? Стойкость и вероятность ошибки расшифрования связаны; стандарт фиксирует компромисс, а произвольные изменения ломают доказательство.
12. Что такое crypto-agility? Способность менять алгоритмы без переделки архитектуры: версии в форматах, OID вместо жёстких констант, инвентаризация и мониторинг.
13. Почему random в Python не годится для ключей? Это вихрь Мерсенна — детерминированный генератор, предсказуемый по нескольким выходам. Нужен secrets или os.urandom.

Глоссарий темы

Шпаргалка по инструментам

OpenSSL: постквантовые алгоритмы

openssl version
openssl list -kem-algorithms | grep -i ml-kem
openssl list -signature-algorithms | grep -i -E "ml-dsa|slh-dsa"

openssl genpkey -algorithm ML-KEM-768 -out mlkem.pem
openssl pkey -in mlkem.pem -pubout -outform DER | wc -c     # 1206
openssl genpkey -algorithm ML-DSA-65 -out mldsa.pem
openssl pkey -in mldsa.pem -pubout -outform DER | wc -c

TLS: сравнение групп

# классический обмен
openssl s_client -connect host:443 -tls1_3 -groups X25519 -brief </dev/null

# гибрид
openssl s_client -connect host:443 -tls1_3 -groups X25519MLKEM768 -brief </dev/null

# размер ClientHello
openssl s_client -connect host:443 -tls1_3 -msg 2>/dev/null | grep -m1 ClientHello

Python: правильные источники случайности

import secrets
import os
import hashlib

key = secrets.token_bytes(32)         # ключ
nonce = os.urandom(12)                # nonce для AEAD
token = secrets.token_urlsafe(32)     # токен для ссылки
code = secrets.randbelow(10 ** 6)     # числовой код

# никогда так:
# import random; random.randrange(256)

Проверка на типичные ошибки

Что почитать и посмотреть

• FIPS 203, 204, 205 — стандарты. Читать не формулы, а разделы про кодирование, проверки и отбраковку: именно там живут уязвимости.
• Bernstein, Lange «Post-Quantum Cryptography» (Nature, 2017) — короткий обзор поля для инженера, без формул.
• Gidney, Ekerå «How to factor 2048 bit RSA integers in 8 hours» — оценки ресурсов, на которые ссылаются все.
• Castryck, Decru «An efficient key recovery attack on SIDH» — как выглядит взлом финалиста конкурса.
• Regev «On lattices, learning with errors...» — исходная работа; читать введение и определение, дальше по желанию.
• NIST IR 8547 — план перехода: что и когда объявляется устаревшим.
• CWE Top 25 — список самых распространённых слабостей; полезно как чек-лист код-ревью.

Углубление (по желанию)

Почему решётки, а не коды. Classic McEliece старше и лучше изучен, но его открытый ключ — сотни килобайт, что тяжело для TLS. Решётки дают приемлемые размеры и быстрые операции, поэтому выиграли конкурс. Это не значит, что коды хуже: в сценариях, где ключ статичен (прошивки, спутники), McEliece остаётся отличным выбором.

Атаки на реализации ML-KEM. Схема стойка, но реализация может утекать: атаки по времени на NTT, по кэшу на таблицы, по энергопотреблению. Отсюда требования к постоянному времени и к защите от утечек — те же, что в теме 13 для кривых. Формально стойкая схема с неаккуратной реализацией не защищает ни от чего.

Миграция сертификатов. X.509 умеет нести любой алгоритм через OID, но размеры цепочек с ML-DSA создают проблемы: некоторые клиенты и балансировщики имеют жёсткие лимиты на размер Certificate. Поэтому обсуждаются «сжатые» сертификаты, повторное использование ключей и отдельные цепочки для PQ-подписей. Это инженерная, а не криптографическая задача, и она займёт годы.

Что делать студенту. Практический минимум: писать код так, чтобы его можно было проверить (тесты, тестовые векторы), не изобретать примитивы, использовать высокоуровневые библиотеки и знать список CWE наизусть. Криптография прощает ошибки в математике и не прощает их в инженерии.

Лабораторная работа 16. Постквантовые схемы и аудит криптографии

• Раздел курса: тема 16 «Постквантовая криптография и практика безопасного применения»

Введение

Тема 16 объяснила, что квантовый компьютер ломает асимметричную криптографию и вдвое ослабляет симметричную, а стандарты 2024 года дают готовые замены. Лабораторная работа проходит три уровня: сначала хеш-подписи — Лэмпорт и дерево Меркла, потом решётки — учебная схема Регева с наглядной демонстрацией роли шума, потом проверка ML-KEM в реальном OpenSSL. Завершает работу аудит: модуль «Сейф» с десятью заложенными ошибками из всех тем курса нужно разобрать по CWE и исправить.

Работа опирается на темы 8 (хеши и деревья Меркла), 9 (AEAD и сравнение за постоянное время), 10 (KDF) и 13 (кривые). Она завершает курс: всё, что разбиралось по отдельности, здесь собирается в один чек-лист.

Цель работы

Реализовать одноразовую подпись Лэмпорта и дерево Меркла, оценить размеры; реализовать учебную схему на LWE, показать роль шума и восстановить секрет при его отсутствии; проверить поддержку ML-KEM в OpenSSL и измерить цену гибридного обмена; провести аудит учебного модуля и классифицировать найденные ошибки.

После выполнения работы можно будет:

• реализовать подпись Лэмпорта и объяснить, почему она одноразовая;
• построить дерево Меркла и доказательство включения;
• оценить размеры ключей и подписей для хеш-схем;
• реализовать схему Регева на LWE и расшифровать бит;
• показать, что без шума секрет восстанавливается методом Гаусса;
• проверить наличие ML-KEM и гибридных групп в OpenSSL;
• измерить рост ClientHello при гибридном обмене;
• найти и классифицировать по CWE десять криптографических ошибок.

Уровни работы

• Минимум (обязательно): части 1–4. Выполняется без внешней сети, только с пакетами из перечня оснащения.
• Практический уровень: 5–6.
• Углубление (по желанию): нет.

Теоретический минимум

Нужны разделы «Стандарты 2024 года», «Учебная криптография на решётках», «Хеш-подписи» и «Практика безопасного применения».

Лэмпорт      pk[i][b] = H(sk[i][b]); подпись раскрывает sk[i][d[i]]
дерево       лист = H(pk), узел = H(left ‖ right), корень = открытый ключ
LWE          b = A·s + e (mod q);  d = v − s·u = Σe + bit·(q/2)
ML-KEM       гибрид: secret = HKDF(ss_x ‖ ss_k)

Перечень оснащения

• Ubuntu 24.04 (или WSL2), Python 3.10 и новее, cryptography, OpenSSL 3.0 или новее (ML-KEM — только с 3.5). Права root не нужны.
• Архив окружения: lr-env.zip.

Ограничения ресурсов

LWE с n = 8…16; Лэмпорт — 256 бит; ML-KEM проверяется по версии OpenSSL, а при её отсутствии — по тестовым значениям из окружения. Время выполнения не нормируется: проверяются свойства и совпадение с тестовыми векторами, а не абсолютные секунды. Если на конкретной машине шаг занимает заметно больше ожидаемого, это фиксируется в журнале вместе с параметрами оборудования.

Безопасная область эксперимента

Работа выполняется в отдельном каталоге ~/crypto-lab-16; всё необходимое лежит в архиве окружения. Учебные серверы и оракулы слушают только 127.0.0.1. Внешняя сеть не используется.

Порядок выполнения работы

mkdir -p ~/lab16 && cd ~/lab16
unzip /path/to/lr-env.zip
cd lr-env
python3 check_lamport.py -v
python3 check_lwe.py -v

Обе проверки должны упасть с NotImplementedError — это нормально, пока функции не реализованы. По мере заполнения TODO запускайте их снова.

Часть 1. Одноразовая подпись Лэмпорта

Задание

1. Реализуйте keygen, sign, verify по описанию в теме. Ключи должны быть детерминированы при заданном seed: sk[i][b] = H(seed ‖ i ‖ b), pk[i][b] = H(sk[i][b]).
2. Проверьте форму ключей и совпадение с тестовыми векторами:

python3 check_lamport.py -v

3. Измерьте размеры:

import lamport_template as lp
sk, pk = lp.keygen(b"demo")
sig = lp.sign(sk, b"seif")
print("подпись:", len(b"".join(sig)), "байт")
print("секрет:", len(b"".join(v for pair in sk for v in pair)), "байт")
print("открытый ключ:", len(b"".join(v for pair in pk for v in pair)), "байт")

Ожидается подпись 8192 байта, секрет и открытый ключ — по 16 384 байта.

4. Убедитесь, что подпись одноразовая: подпишите два разных сообщения и посчитайте, для скольких битов раскрылись оба секрета. Проверка test_reuse_reveals_both_secrets делает это автоматически и ожидает больше 80 различающихся битов.
5. Ответьте: почему для 256-битного дайджеста нужно ровно 512 секретов, а не 256?

Что должно получиться

Работающая подпись, проходящая проверки, и понимание, что цена стойкости без алгебры — размер и одноразовость.

Часть 2. Дерево Меркла

Задание

1. Реализуйте merkle_root, merkle_proof и merkle_verify. Лист — H(сериализованного ключа Лэмпорта), узел — H(left ‖ right). Нечётный узел поднимается на уровень выше без пары.
2. Проверьте дерево для 8 и для 5 ключей:

python3 check_lamport.py -v

Проверки включают неверный индекс, неверный корень и нечётное число листьев.

3. Измерьте размер доказательства:

import lamport_template as lp
keys = [lp.keygen(f"s{i}".encode())[1] for i in range(8)]
print("доказательство:", sum(map(len, lp.merkle_proof(keys, 3))), "байт")

Для 8 листьев — 96 байт (три хеша), для 2^20 — 640 байт (двадцать хешей).

4. Убедитесь, что подмена листа ломает корень: возьмите доказательство для индекса 2 и проверьте его для ключа с индексом 3.
5. Ответьте: почему дерево Меркла позволяет использовать много одноразовых ключей, но не решает проблему состояния для XMSS и LMS?

Что должно получиться

Работающее дерево с доказательствами и понимание компромисса: log₂ N хешей в подписи против N ключей, которые нужно сгенерировать заранее.

Часть 3. Схема Регева на LWE

Задание

1. Реализуйте lwe_keygen, lwe_encrypt, lwe_decrypt по формулам из темы. Параметры: n = 8, q = 97, m = 16, секрет и ошибки из {−1, 0, 1}.
2. Проверьте обратимость и долю ошибок:

python3 check_lwe.py -v

Проверка допускает не более двух ошибок на сто битов. При учебных параметрах ошибок обычно не бывает вовсе.

3. Поэкспериментируйте с размером шума. Замените распределение ошибок на равномерное по {−3, ..., 3} и посмотрите, как меняется доля ошибок расшифрования. Объясните результат через порог q/4.
4. Убедитесь, что шифрование вероятностное: два шифрования одного бита дают разные (u, v).
5. Ответьте: что произойдёт со стойкостью, если уменьшить шум «чтобы не было ошибок»?

Что должно получиться

Работающая схема, понимание, что шум — не помеха, а защита, и что порог расшифрования — это количественное ограничение на сумму ошибок.

Часть 4. Атака без шума

Задание

1. Реализуйте recover_secret_noiseless: приведение матрицы A к ступенчатому виду над GF(q) и обратный ход. Если система несовместна, возбудите ValueError.
2. Проверьте на системе без шума и с шумом:

python3 check_lwe.py -v -k TestNoiselessAttack

3. Сгенерируйте систему с шумом и убедитесь, что метод Гаусса либо падает, либо даёт неверный ответ:

import random, lamport_template as lp
rng = random.Random(1)
s = [rng.choice([-1, 0, 1]) for _ in range(8)]
A = [[rng.randrange(97) for _ in range(8)] for _ in range(16)]
e = [rng.choice([-1, 0, 1]) for _ in range(16)]
b = [(sum(A[i][j] * s[j] for j in range(8)) + e[i]) % 97 for i in range(16)]
try:
    print(lp.recover_secret_noiseless(A, b, 97) == [x % 97 for x in s])
except ValueError as exc:
    print("несовместна:", exc)

4. Ответьте: почему в реальной схеме количество уравнений m больше размерности n, и что это даёт?

Что должно получиться

Наглядная демонстрация: без шума LWE тривиальна, с шумом — нет. Это ядро всей постквантовой криптографии на решётках.

Часть 5. ML-KEM в OpenSSL

Задание

1. Проверьте, что есть в вашей версии OpenSSL:

openssl version
openssl list -kem-algorithms | grep -i ml-kem

Если строк нет — версия ниже 3.5; зафиксируйте это в отчёте честно и переходите к пункту 4.

2. Сгенерируйте ключ ML-KEM-768 и измерьте размер открытого ключа:

openssl genpkey -algorithm ML-KEM-768 -out mlkem.pem
openssl pkey -in mlkem.pem -pubout -outform DER | wc -c

Ожидается 1206 байт в DER (1184 байта ключа плюс заголовок).

3. Сравните размеры с классическими: openssl genpkey -algorithm X25519 даёт открытый ключ 44 байта в DER.

4. Измерьте цену гибрида в TLS. Поднимите сервер на сертификате из ЛР 15 (или соберите его скриптом make_pki.sh из той работы) и сравните размер ClientHello:

openssl s_client -connect 127.0.0.1:8443 -tls1_3 -groups X25519 -msg 2>/dev/null | grep -m1 ClientHello
openssl s_client -connect 127.0.0.1:8443 -tls1_3 -groups X25519MLKEM768 -msg 2>/dev/null | grep -m1 ClientHello

Ожидается 221 байт против 1399 байт — рост почти на килобайт.

5. Ответьте: почему гибрид включает оба обмена, а не только постквантовый?

Что должно получиться

Проверенные числа и понимание, что внедрение постквантовой криптографии измеряется в байтах трафика, а не только в стойкости.

Часть 6. Аудит модуля «Сейф»

Задание

1. Откройте vulnerable/seif_audit.py. В нём десять намеренных ошибок, охватывающих темы курса: пароли, KDF, случайность, режимы шифрования, MAC, RSA, токены.
2. Для каждой ошибки заполните строку в audit_notes.md: строка кода, класс CWE, что именно ломается, как исправить.
3. Ориентируйтесь на чек-лист из темы: CWE-327, 328, 329, 330, 331, 338, 347, 353, 798, 916.
4. Отдельно ответьте на вопросы из audit_notes.md: какие ошибки дают раскрытие открытого текста, какие — подделку, какие проявляются только при взаимодействии функций.
5. Предложите исправленный вариант каждой функции. Проверять его не нужно, но код должен быть рабочим.

Что должно получиться

Заполненная таблица на десять строк и исправленный код. Это самое практичное задание курса: узнать ошибку в чужом коде проще, чем не допустить её в своём.

Журнал работы

В журнал записываются числа и вывод команд. Отчёт без измерений считается невыполненным.

Критерии проверки

Работа считается выполненной, если:

• проверки check_lamport.py и check_lwe.py завершаются без ошибок;
• подпись Лэмпорта проверена и повторное использование ключа отвергнуто, LWE расшифровывается только при малом шуме, ML-KEM подтверждён или честно зафиксировано его отсутствие, аудит нашёл все заложенные ошибки;
• измерения и наблюдения записаны в журнал вместе с объяснением расхождений с предсказанием;
• на контрольные вопросы даны ответы своими словами, а не пересказ команд.

Контрольные вопросы

1. Почему алгоритм Шора ломает и RSA, и ECDSA, а алгоритм Гровера — только ослабляет AES?
2. Что такое «сохрани сейчас — расшифруй потом» и почему из-за него нельзя ждать?
3. Чем ML-KEM отличается от ECDH по интерфейсу (KEM против обмена)?
4. Почему в гибридном обмене секреты комбинируют через KDF, а не сложением?
5. Почему подпись Лэмпорта одноразовая и что произойдёт при повторном использовании?
6. Как дерево Меркла превращает одноразовую подпись в многократную?
7. Почему XMSS и LMS требуют хранения состояния, а SLH-DSA — нет?
8. В чём роль шума в LWE и что произойдёт, если его убрать?
9. Почему нельзя самостоятельно выбирать параметры ML-KEM?
10. Какой рост размера рукопожатия даёт гибрид X25519MLKEM768 и чем это грозит?
11. Назовите три ошибки из аудита, которые не видны при чтении одной функции.
12. Почему сертификация СКЗИ не гарантирует отсутствие уязвимостей?