Cryptography on kenji.blog

Основы и реализация криптографии с использованием малой теоремы Ферма

Fri, 11 Sep 2026 22:00:00 +0900

1. Введение: Тайна математики, лежащая в основе современной криптографии

В современном цифровом обществе, особенно в связи с передачей данных через Интернет, «криптография» стала неотъемлемой базовой технологией. То, что мы можем безопасно просматривать веб-сайты через HTTPS в веб-браузерах, совершать финансовые операции в онлайн-банкинге и приватно общаться в приложениях для обмена сообщениями, возможно благодаря криптографическим протоколам, работающим в фоновом режиме и опирающимся на продвинутую математическую теорию. Среди них особо важную роль играет «криптография с открытым ключом», ярким представителем которой является алгоритм RSA.

Безопасность и корректность многих криптографических алгоритмов, включая RSA, во многом зависят от очень красивой и мощной теоремы, открытой в 17 веке французским математиком Пьером де Ферма (Pierre de Fermat). Это Малая теорема Ферма (Fermat’s Little Theorem). Кроме того, теорема Леонарда Эйлера (Leonhard Euler), которая является ее обобщением, также играет решающую роль в теории криптографии.

В этой статье подробно и с самых основ объясняется, как открытие из области чистой математики, такое как малая теорема Ферма, применяется в современных практических криптографических технологиях, в частности, для «проверки на простоту» и в «алгоритме RSA». Это очень подробное техническое руководство, охватывающее математические доказательства, механизмы шифрования и дешифрования, а также конкретные реализации алгоритмов на C++ и Python.

2. Основы сравнений и модульной арифметики

Чтобы понять малую теорему Ферма, сначала необходимо ознакомиться с математической концепцией «модульной арифметики (сравнений по модулю)». Модульная арифметика — это система вычислений, в которой основное внимание уделяется «остатку» от деления на определенное заданное число (называемое модулем). Поскольку вычисления похожи на циферблат часов (который делает полный оборот за 12 часов), ее также называют «арифметикой часов».

Когда остатки от деления целых чисел $a$ и $b$ на положительное целое число $n$ равны, математически это записывается следующим образом:

$$ a \equiv b \pmod n $$

Это читается как «$a$ и $b$ сравнимы по модулю $n$». Например, остаток от деления 17 на 5 равен 2, и остаток от деления 12 на 5 также равен 2. Поэтому мы можем записать:

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

В модульной арифметике обычные четыре арифметических действия (сложение, вычитание, умножение) работают так же:

Сложение: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a + c \equiv b + d \pmod n$
Вычитание: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a - c \equiv b - d \pmod n$
Умножение: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a \times c \equiv b \times d \pmod n$
Возведение в степень: Если $a \equiv b \pmod n$, то для любого натурального числа $k$ верно $a^k \equiv b^k \pmod n$

Однако с делением следует быть осторожными. В общем случае, из того, что $a \times c \equiv b \times c \pmod n$, нельзя разделить обе части на $c$ и получить $a \equiv b \pmod n$. Это справедливо только в том случае, когда $c$ и $n$ взаимно просты (их наибольший общий делитель равен 1). Эта концепция «модульного обратного элемента» станет чрезвычайно важной при генерации ключей RSA, которая будет обсуждаться позже.

3. Математические основы и доказательство малой теоремы Ферма

Теперь, когда мы усвоили основы модульной арифметики, давайте перейдем к главной теме — малой теореме Ферма.

3.1 Определение теоремы

Малая теорема Ферма формулируется следующим образом:

Малая теорема Ферма (Fermat’s Little Theorem) Пусть $p$ — простое число, а $a$ — любое целое число, не кратное $p$ (то есть $a$ и $p$ взаимно просты). Тогда справедливо следующее сравнение:
$$ a^{p-1} \equiv 1 \pmod p $$

Также часто встречается форма, в которой условие «$a$ не кратно $p$» убирается, и теорема выражается в виде, справедливом для всех целых чисел $a$. В этом случае, если умножить обе части на $a$, мы получим:

$$ a^p \equiv a \pmod p $$

3.2 Проверка на конкретных примерах

Давайте проверим на конкретных числах, действительно ли работает эта теорема. Пусть простое число $p = 5$. Тогда $p-1 = 4$. В качестве $a$ выберем целые числа, не кратные $p$.

Для $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ с остатком $1$. Следовательно, $16 \equiv 1 \pmod 5$. (Выполняется)
Для $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ с остатком $1$. Следовательно, $81 \equiv 1 \pmod 5$. (Выполняется)
Для $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ с остатком $1$. Следовательно, $256 \equiv 1 \pmod 5$. (Выполняется)

Таким образом, какое бы $a$ мы ни выбрали (при условии, что оно не кратно 5), остаток от деления 4-й степени на 5 всегда будет равен 1. Это выглядит как магия, но проистекает из прекрасных свойств простых чисел.

3.3 Математическое доказательство теоремы

Почему же это справедливо? Здесь мы приведем элегантное доказательство с использованием множества классов вычетов.

Рассмотрим множество $S = \{1, 2, 3, \dots, p-1\}$. Это представители целых чисел, остатки от деления которых на $p$ находятся в диапазоне от $1$ до $p-1$. Теперь рассмотрим новое множество $T$, полученное умножением каждого элемента на целое число $a$, взаимно простое с $p$:

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

Рассмотрим остатки от деления каждого элемента множества $T$ на $p$. Удивительно, но эти остатки (возможно, в другом порядке) полностью совпадают с множеством элементов исходного множества $S$. Это происходит потому что:

Никакой элемент $T$ не может быть кратен $p$ (так как ни $a$, ни исходные элементы не кратны $p$).
В $T$ не существует двух различных элементов, сравнимых по модулю $p$. Если бы $ia \equiv ja \pmod p$ (при $i \neq j$), то, поскольку $a$ и $p$ взаимно просты, мы могли бы разделить обе части на $a$, получив $i \equiv j \pmod p$, что является противоречием.

Таким образом, произведение всех элементов множества $S$ сравнимо с произведением всех элементов множества $T$ по модулю $p$:

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

Если преобразовать левую часть, мы получим $p-1$ множителей $a$, поэтому:

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

Поскольку $(p-1)!$ взаимно просто с $p$, мы можем разделить обе части на $(p-1)!$, и в итоге выводится следующая теорема:

$$ a^{p-1} \equiv 1 \pmod p $$

Это и есть доказательство малой теоремы Ферма.

4. Функция Эйлера и теорема Эйлера

Малая теорема Ферма касается «простого числа $p$», но Леонард Эйлер обобщил ее для «любого положительного целого числа $n$». Это расширение необходимо для понимания алгоритма RSA.

4.1 Функция Эйлера $\phi(n)$

Функция Эйлера (также называемая тотиентом или $\phi$-функцией Эйлера) $\phi(n)$ представляет собой функцию, возвращающую «количество целых чисел от $1$ до $n$, взаимно простых с $n$».

В случае простого числа $p$ все целые числа от $1$ до $p-1$ взаимно просты с $p$, поэтому $\phi(p) = p - 1$.
Для двух различных простых чисел $p$ и $q$, в случае их произведения $n = p \times q$, $\phi(n)$ вычисляется по очень простой формуле: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Это свойство становится фундаментальной логикой при генерации ключей RSA.

4.2 Теорема Эйлера

Эйлер обобщил малую теорему Ферма следующим образом:

Теорема Эйлера (Euler’s Theorem) Для любого положительного целого числа $n$ и взаимно простого с ним целого числа $a$ справедливо следующее:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Если $n$ — простое число $p$, то $\phi(p) = p - 1$, и это становится самой малой теоремой Ферма ($a^{p-1} \equiv 1 \pmod p$). Иными словами, малая теорема Ферма является лишь частным случаем теоремы Эйлера.

5. Поиск огромных простых чисел: Тест Ферма на простоту

В криптографических технологиях (таких как алгоритм RSA или обмен ключами Диффи-Хеллмана) необходимо быстро находить «огромные простые числа», длина которых может составлять сотни цифр. Однако, чтобы определить, является ли огромное число $N$ простым с помощью метода «перебора делителей» от $2$ до $\sqrt{N}$, потребовалось бы время, сравнимое с возрастом Вселенной.

И здесь на помощь приходит «вероятностный тест на простоту», использующий малую теорему Ферма наоборот. Он называется тест Ферма (Fermat Primality Test).

5.1 Что такое вероятностный тест на простоту

Согласно малой теореме Ферма, если $p$ — простое число, то для любого $a$ ($1 < a < p$) обязательно выполняется $a^{p-1} \equiv 1 \pmod p$. Если взять контрапозицию, то можно сказать: «Если для некоторого $a$ выполняется $a^{p-1} \not\equiv 1 \pmod p$, то $p$ абсолютно точно не является простым (является составным числом)».

Следовательно, если мы хотим проверить, является ли число $N$ простым, мы случайно выбираем несколько чисел $a$, вычисляем $a^{N-1} \pmod N$ и проверяем, равно ли это $1$. Если хотя бы раз ответ будет отличным от $1$, то точно установлено, что $N$ — составное число. Если же мы пробуем много раз и всегда получаем $1$, то с высокой долей вероятности можно судить, что $N$ «вероятно, простое».

5.2 Объяснение алгоритма и блок-схема

Алгоритм теста Ферма выглядит следующим образом:

flowchart TD Start["Начало"] --> Input["Ввести проверяемое число p и количество проверок k"] Input --> LoopStart["Цикл от i = 0 до k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Да" --> RandomA["Случайно выбрать целое число a в диапазоне 1 < a < p-1"] RandomA --> Calc["Вычислить модульное возведение в степень a^(p-1) mod p"] Calc --> CheckPrime{"Результат равен 1 ?"} CheckPrime -- "Нет" --> ReturnComposite["p является составным (точно)"] CheckPrime -- "Да" --> Increment["Увеличить i на 1"] Increment --> Condition Condition -- "Нет" --> ReturnPrime["p, вероятно, является простым (с высокой вероятностью)"] ReturnComposite --> End["Конец"] ReturnPrime --> End

5.3 Подводный камень: числа Кармайкла (псевдопростые)

Тест Ферма очень быстр, но у него есть один существенный недостаток. Существуют такие дьявольские числа, которые, будучи составными, удовлетворяют условию $a^{N-1} \equiv 1 \pmod N$ для всех возможных $a$. Такие числа называются числами Кармайкла (Carmichael numbers). Наименьшим числом Кармайкла является $561$ ($3 \times 11 \times 17$).

Из-за существования чисел Кармайкла только лишь с помощью теста Ферма нельзя абсолютно точно определить простоту числа. Поэтому в реальных криптографических системах (таких как OpenSSL) стандартно используется усовершенствованная версия теста Ферма — тест простоты Миллера-Рабина (Miller-Rabin Primality Test). Поскольку алгоритм Миллера-Рабина способен выявлять числа Кармайкла, вероятность ложного срабатывания может быть сведена практически к нулю.

5.4 Быстрое модульное возведение в степень (метод бинарного возведения в степень)

В алгоритме проверки на простоту необходимо вычислять $a^{N-1} \pmod N$, но если $N$ огромно, то $a^{N-1}$ будет иметь астрономическое количество цифр и не поместится в память компьютера. Решением этой проблемы является метод бинарного возведения в степень (Exponentiation by Squaring), или быстрое модульное возведение в степень. Путем взятия остатка (mod N) на каждом шаге вычисления значение всегда сохраняется меньше $N$, что позволяет выполнять вычисления очень быстро (со сложностью $O(\log N)$).

6. Реализация проверки на простоту и модульного возведения в степень

Теперь давайте реализуем тест Ферма на простоту и метод бинарного возведения в степень на C++ и Python.

6.1 Реализация на C++

В C++ стандартные целочисленные типы подвержены переполнению, поэтому для работы с большими числами требуются библиотеки многократной точности (например, GMP), но здесь мы приведем реализацию в пределах 64-битных целых чисел (unsigned long long) для понимания алгоритма.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// Быстрое модульное возведение в степень (a^b mod m) - метод бинарного возведения в степень
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Если младший бит b равен 1, умножаем результат на a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Расширение до 128 бит для предотвращения переполнения
 }
 // Возводим a в квадрат
 a = (__int128)a * a % m;
 // Сдвигаем b вправо (делим пополам)
 b /= 2;
 }
 return result;
}

// Тест Ферма на простоту
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Если a^(p-1) mod p не равно 1, то это составное число
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Вероятно, простое
}

int main() {
 unsigned long long num = 1000000007; // Известное простое число
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Реализация на Python

Стандартный целочисленный тип в Python поддерживает числа произвольной точности, поэтому не нужно беспокоиться о переполнении. Кроме того, встроенная функция Python pow(a, b, m) внутренне использует метод бинарного возведения в степень и работает очень быстро.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 Вероятностный тест на простоту с использованием теста Ферма
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Выбираем случайное число a от 2 до p-2
 a = random.randint(2, p - 2)
 # Вычисляем a^(p-1) mod p. Встроенная функция pow работает быстро.
 if pow(a, p - 1, p) != 1:
 return False # Точно составное число

 return True # Вероятно, простое

# Тестирование
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} вероятно, является простым.")
else:
 print(f"{number_to_test} является составным.")

7. Применение в алгоритме RSA: Место встречи Ферма и Эйлера

Самым великим применением малой теоремы Ферма (и теоремы Эйлера) является алгоритм RSA, разработанный в 1977 году Ривестом, Шамиром и Адлеманом. RSA — это инновационная криптографическая система с «открытым ключом», в которой ключ для шифрования (открытый ключ) доступен всему миру, а ключ для дешифрования (закрытый ключ) известен только самому получателю.

Эта асимметричность основана на вычислительной безопасности, обусловленной тем, что «разложение огромного составного числа на простые множители является чрезвычайно сложной задачей».

7.1 Механизм RSA (генерация ключей, шифрование, дешифрование)

Давайте рассмотрим весь процесс обмена данными в алгоритме RSA с помощью диаграммы последовательности Mermaid.

sequenceDiagram participant Alice["Алиса (Получатель)"] participant Bob["Боб (Отправитель)"] Alice->>Alice: "Сгенерировать огромные простые числа p, q" Alice->>Alice: "Вычислить N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Вычислить открытый ключ e и закрытый ключ d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Отправить открытый ключ (N, e)" Note over Bob: "Подготовить открытый текст M (M < N)" Bob->>Bob: "Вычислить шифротекст C = M^e mod N" Bob->>Alice: "Отправить шифротекст C" Alice->>Alice: "Вычислить открытый текст M = C^d mod N и расшифровать"

Ниже описаны подробные математические шаги.

Шаг 1: Генерация ключей (действия получателя Алисы)

Случайным образом генерируются два огромных простых числа $p$ и $q$ (здесь используется упомянутый ранее тест на простоту).
Вычисляется их произведение $N = p \times q$. Это значение $N$ публикуется открыто.
Используя функцию Эйлера, вычисляется $\phi(N) = (p-1)(q-1)$.
Выбирается целое число $e$ (открытая экспонента), взаимно простое с $\phi(N)$ (часто используется $e = 65537$).
Вычисляется модульный обратный элемент $d$ (закрытая экспонента) для $e$. То есть, находится такое $d$, которое удовлетворяет условию: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Для этих вычислений используется расширенный алгоритм Евклида.

Таким образом, открытым ключом становится пара $(N, e)$, а закрытым ключом — пара $(N, d)$. (Значения $p, q, \phi(N)$ следует немедленно уничтожить или строго хранить в секрете).

Шаг 2: Шифрование (действия отправителя Боба)

Предположим, Боб хочет отправить Алисе сообщение $M$ (где $M$ — это преобразованный в числа текст, и $0 \le M < N$). Боб использует открытый ключ Алисы $(N, e)$ для вычисления шифротекста $C$ следующим образом:

$$ C \equiv M^e \pmod N $$

Затем этот $C$ передается Алисе по сети.

Шаг 3: Дешифрование (действия получателя Алисы)

Получив шифротекст $C$, Алиса использует свой закрытый ключ $d$, который знает только она, для выполнения следующего вычисления:

$$ M' \equiv C^d \pmod N $$

Поразительно, но результат этого вычисления $M'$ полностью совпадает с исходным сообщением $M$.

7.2 Почему возможна расшифровка? (Математическое доказательство)

Здесь малая теорема Ферма (и теорема Эйлера) проявляет свою истинную ценность. Почему $C^d \pmod N$ превращается обратно в $M$?

Давайте раскроем формулу дешифрования. Поскольку $C \equiv M^e \pmod N$, то:

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

На шаге генерации ключей мы выбрали $d$ таким образом, что $e \cdot d \equiv 1 \pmod{\phi(N)}$. Это означает, что существует некоторое целое число $k$, при котором можно записать:

$$ e \cdot d = 1 + k \cdot \phi(N) $$

Подставим это в верхнюю формулу:

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

Здесь и появляется теорема Эйлера ($M^{\phi(N)} \equiv 1 \pmod N$). (※Строго говоря, $M$ и $N$ должны быть взаимно простыми, но в RSA вероятность того, что $M$ и $N$ не взаимно просты, астрономически мала, и, используя китайскую теорему об остатках, можно доказать, что это будет работать, даже если они не взаимно просты).

Применяя теорему Эйлера, так как $M^{\phi(N)} \equiv 1$, получаем:

$$ M \cdot (1)^k \equiv M \pmod N $$

$M$ чудесным образом восстановлено! Свойства чисел, открытые Ферма и Эйлером столетия назад, идеально гарантируют конфиденциальность современной цифровой связи.

8. Игрушечная реализация алгоритма RSA (Python)

Только в теории все может казаться сложным, поэтому давайте используем Python для фактической реализации процесса генерации ключей, шифрования и дешифрования RSA. Хотя это обучающая «игрушечная реализация», используемая математика абсолютно реальна.

Мы также включим в реализацию «расширенный алгоритм Евклида» для нахождения модульного обратного элемента $d$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# Нахождение наибольшего общего делителя
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Расширенный алгоритм Евклида (находим x, y для ax + by = gcd(a,b))
# Используется для нахождения d из e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('Обратного элемента не существует')
 else:
 return x % phi

# Функция генерации простых чисел (упрощенная: генерирует небольшие простые числа)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Упрощенная проверка вместо упомянутого ранее теста Ферма
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Генерация ключей RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Убедимся, что p и q не одинаковые
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # Для e часто используют простые числа, например 65537, но здесь выберем случайно
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Вычисление закрытого ключа d
 d = mod_inverse(e, phi)

 # Открытый ключ (e, n), Закрытый ключ (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Вычисляем plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Вычисляем cipher^d mod n и преобразуем обратно в символы
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Пример выполнения
if __name__ == '__main__':
 print("--- Игрушечная реализация RSA ---")
 public_key, private_key = generate_keypair(bits=12) # Используем 12-битные простые числа

 print(f"Открытый ключ (e, n): {public_key}")
 print(f"Закрытый ключ (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nИсходное сообщение: {message}")

 # Шифрование
 encrypted_msg = encrypt(public_key, message)
 print(f"Шифротекст: {encrypted_msg}")

 # Дешифрование
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Расшифрованное сообщение: {decrypted_msg}")

При запуске этого кода вы увидите, как массив символов преобразуется в массив незнакомых чисел (шифротекст), а затем блестяще восстанавливается в исходную строку с помощью закрытого ключа.

9. Заключение: Место пересечения красоты и практичности математики

Когда в 17 веке Пьер де Ферма открыл эту «малую теорему», никто не мог подумать, что она когда-нибудь пригодится. Сам Ферма занимался теорией чисел исключительно из чистого математического любопытства.

Однако почти 300 лет спустя, в 1970-х годах, на заре компьютерных сетей теорема Ферма совершила драматическое возрождение в качестве криптографической технологии, необходимой для создания безопасных протоколов связи. Метод проверки простоты, основанный на малой теореме Ферма, и алгоритм RSA, основанный на теореме Эйлера, буквально поддерживают инфраструктуру современного Интернета.

И сообщения в мессенджерах, которые мы отправляем каждый день, и покупки на Amazon — все это танцует на фундаменте одной простой и красивой формулы: $a^{p-1} \equiv 1 \pmod p$. Малая теорема Ферма учит нас тому, что независимо от того, насколько абстрактной может быть математика, однажды обязательно наступит время, когда она послужит человечеству.

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

Математическая интуиция криптографии на решетках (Lattice-based cryptography)

Fri, 11 Sep 2026 21:00:00 +0900

1. Введение: Рассвет постквантовой криптографии (PQC) и расцвет криптографии на решетках

Цифровая инфраструктура современного общества опирается на технологии криптографии с открытым ключом, такие как RSA и криптография на эллиптических кривых (ECC). Эти методы шифрования основывают свою безопасность на математической сложности таких задач, как “факторизация целых чисел” и “проблема дискретного логарифма”, которые, как считается, не могут быть эффективно решены (требуют экспоненциального времени) классическими компьютерами.

Однако “алгоритм Шора”, опубликованный Питером Шором (Peter Shor) в 1994 году, потряс криптографический мир. Этот алгоритм математически доказал, что когда будут созданы крупномасштабные квантовые компьютеры, они смогут решать проблемы факторизации и дискретного логарифма за полиномиальное время. Это означает, что широко используемая сегодня криптография с открытым ключом в будущем станет полностью уязвимой для расшифровки.

Чтобы противостоять этой “квантовой угрозе” (Quantum Threat), возникла острая необходимость в исследовании новых методов шифрования, которые трудно взломать даже с помощью квантовых компьютеров. Эта область называется “постквантовой криптографией” (Post-Quantum Cryptography: PQC).

В PQC существует несколько перспективных кандидатов, таких как криптография на основе хешей, криптография на основе кодов, многомерная полиномиальная криптография и криптография на основе изогений. Однако “криптография на решетках” (Lattice-based cryptography) в настоящее время привлекает наибольшее внимание и является центральным элементом процесса стандартизации PQC Национальным институтом стандартов и технологий США (NIST). По сравнению с другими методами, криптография на решетках обладает чрезвычайно высокой скоростью шифрования и дешифрования, а также выдающейся особенностью: она имеет очень сильное доказательство безопасности в криптографии — сведение от “сложности в худшем случае” (Worst-case complexity) к “сложности в среднем случае” (Average-case complexity).

В этой статье мы подробно рассмотрим криптографию на решетках, начиная с математического определения “решетки” (Lattice), которая является ее основой. Мы обсудим сложные задачи на решетках, такие как SVP (задача поиска кратчайшего вектора) и CVP (задача поиска ближайшего вектора), а также проблему “LWE (Learning With Errors)”, которая является сердцем современной криптографии на решетках. Будут представлены математические формулы, геометрическая интуиция и конкретные числовые примеры.

2. Математическое определение решетки (Lattice) и геометрическая интуиция

2.1 Векторные пространства и решетки

В математике “решетка” (Lattice) — это множество дискретных точек, регулярно расположенных в $n$-мерном действительном векторном пространстве $\mathbb{R}^n$. Оно похоже на векторное пространство (Vector Space), изучаемое в линейной алгебре, но есть одно решающее отличие. В то время как векторное пространство — это непрерывное пространство, представленное линейными комбинациями базисных векторов с “действительными коэффициентами”, решетка — это дискретное пространство, представленное линейными комбинациями базисных векторов с “целыми коэффициентами”.

Дадим строгое математическое определение. Рассмотрим $n$ ($n \le m$) линейно независимых векторов $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ в $m$-мерном действительном векторном пространстве $\mathbb{R}^m$. Пусть матрица, содержащая эти векторы в качестве столбцов, будет $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. Эта матрица $B$ называется “базисом” (Basis) решетки.

Решетка $\mathcal{L}(B)$, порожденная этим базисом $B$, определяется следующим образом:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

Важно отметить, что коэффициенты $x_i$ ограничены целыми числами $\mathbb{Z}$, а не действительными числами $\mathbb{R}$. В результате образуется “множество дискретных точек”, подобных равномерно расположенным перекресткам, а не непрерывное пространство с бесконечным множеством точек.

2.2 Геометрический образ

Рассмотрим пример в двумерной плоскости $\mathbb{R}^2$. Если мы выберем в качестве базисных векторов $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ и $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$, то порожденная ими решетка будет представлять собой множество всех целочисленных координат $(x, y) \in \mathbb{Z}^2$ на координатной плоскости. Это самая простая “квадратная решетка”.

Однако решетки не всегда ортогональны. Например, если мы рассмотрим базис $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ и $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, то порожденные точки будут напоминать пересечения диагонально искаженной сетки.

2.3 Неоднозначность базиса и унимодулярные преобразования

Существует важное свойство, касающееся основы безопасности криптографии на решетках: “Существует бесконечное количество базисов, порождающих одну и ту же решетку”.

Например, базис $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$, упомянутый ранее, порождает решетку $\mathbb{Z}^2$. Базис $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$ порождает абсолютно ту же самую решетку $\mathbb{Z}^2$.

Необходимым и достаточным условием того, что базис $B$ и другой базис $B'$ порождают одну и ту же решетку, является существование матрицы с целочисленными элементами $U \in \mathbb{Z}^{n \times n}$, определитель которой $\det(U) = \pm 1$, так что:

$$ B' = B U $$

Такая матрица $U$ называется “унимодулярной матрицей” (Unimodular matrix).

Основная идея применения в криптографии состоит в том, чтобы использовать “хороший базис” (почти ортогональный, состоящий из коротких векторов) в качестве секретного ключа, и “плохой базис” (состоящий из очень длинных векторов, сильно скошенных друг относительно друга) в качестве открытого ключа. Вычислить хороший базис из плохого становится крайне сложно по мере увеличения размерности. В этом заключается базовая интуиция криптографии на решетках.

3. Вычислительно сложные задачи на решетках

Безопасность криптографии на решетках зависит от сложности решения определенных математических задач на решетках. Здесь мы представим две самые фундаментальные и известные проблемы.

3.1 Задача поиска кратчайшего вектора (Shortest Vector Problem: SVP)

SVP — это самая классическая и известная задача в теории решеток.

Определение (SVP): Дан произвольный базис решетки $B$. Найдите в решетке $\mathcal{L}(B)$ ненулевой вектор $\mathbf{v}$, евклидова норма (длина) которого минимальна.

Математически это задача поиска вектора $\mathbf{v}$, такого что достигается минимум $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Эта минимальная длина обозначается как $\lambda_1(\mathcal{L})$ и называется “первым последовательным минимумом решетки”.

В низких измерениях, таких как 2D или 3D, можно нарисовать график и визуально найти самый короткий вектор, или эффективно решить задачу с помощью алгоритма редукции решетки Гаусса. Однако известно, что когда размерность $n$ достигает сотен или тысяч, точное решение SVP является NP-трудным.

В реальной криптографии используется приближенная SVP ($\gamma$-SVP), которая находит “приближенно короткий вектор”, а не строго кратчайший вектор. Когда коэффициент аппроксимации $\gamma$ полиномиального размера, эта проблема все еще считается чрезвычайно сложной.

3.2 Задача поиска ближайшего вектора (Closest Vector Problem: CVP)

CVP также является чрезвычайно важной задачей в криптографии на решетках.

Определение (CVP): Дан произвольный базис решетки $B$ и любой целевой вектор $\mathbf{t} \in \mathbb{R}^m$ в пространстве (не обязательно являющийся точкой решетки). Найдите точку решетки $\mathbf{v} \in \mathcal{L}(B)$, ближайшую к $\mathbf{t}$.

Математически это задача поиска точки решетки $\mathbf{v}$, такой что достигается минимум $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

Как и SVP, CVP является NP-трудной в высоких измерениях. С точки зрения применения в криптографии, проблема LWE, которая будет обсуждаться позже, тесно связана с особым вариантом этой CVP (Bounded Distance Decoding: BDD).

3.3 Почему это не решается в высоких размерностях? (Пределы LLL и BKZ)

Известным алгоритмом для решения задач на решетках высокой размерности является алгоритм LLL (алгоритм Ленстры-Ленстры-Ловаса). Алгоритм LLL работает за полиномиальное время и может в некоторой степени “редуцировать” базис решетки до “хорошего базиса”. Однако кратчайший вектор, который может найти алгоритм LLL, имеет коэффициент аппроксимации, который экспоненциально зависит от размерности ($2^{\mathcal{O}(n)}$) по сравнению с истинным кратчайшим вектором, что недостаточно для нарушения безопасности криптографии.

С помощью более мощных алгоритмов редукции базиса, таких как алгоритм BKZ (Block Korkine-Zolotarev), который является улучшением LLL, можно найти более короткие векторы, но вычислительная сложность возрастает экспоненциально в зависимости от размера блока. В криптографии на решетках безопасные параметры (например, значение размерности $n$) определяются путем оценки времени выполнения этого алгоритма BKZ. В текущих стандартных параметрах PQC размерность $n$ выбирается от 500 до 1000 и более, и считается, что для взлома потребуется время, превышающее возраст Вселенной, даже при использовании суперкомпьютеров или будущих квантовых компьютеров.

4. Математическая формулировка проблемы LWE (Learning With Errors)

Большая часть современной криптографии на решетках основана на проблеме “LWE (Learning With Errors)”, предложенной Одедом Регевом (Oded Regev) в 2005 году. Красота проблемы LWE заключается в простоте ее формулировки и мощном математическом доказательстве “сведения от сложности в худшем случае к сложности в среднем случае”.

4.1 Система линейных уравнений без шума

Чтобы понять проблему LWE, давайте сначала рассмотрим простую систему линейных уравнений без шума. Предположим, у нас есть неизвестный секретный вектор $\mathbf{s} \in \mathbb{Z}_q^n$ (где каждая компонента - целое число от $0$ до $q-1$). Здесь $q$ - простое число.

Мы выбираем случайные векторы коэффициентов $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ и вычисляем их скалярное произведение с секретным вектором $\mathbf{s}$ по модулю $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Учитывая достаточное количество (не менее $n$) пар $(\mathbf{a}_i, b_i)$, мы можем легко восстановить секретный вектор $\mathbf{s}$, используя “метод исключения Гаусса” из линейной алгебры. Эту задачу легко решить за полиномиальное время.

4.2 Определение проблемы LWE: Добавление шума

Что произойдет, если мы добавим немного “шума (ошибки)” в эту задачу? В этом суть проблемы LWE.

Для неизвестного секретного вектора $\mathbf{s} \in \mathbb{Z}_q^n$, мы добавляем небольшую ошибку $e_i \in \mathbb{Z}_q$ к результату каждого уравнения. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Здесь $e_i$ - небольшое целое число со средним значением 0 и относительно небольшим стандартным отклонением (например, выбранное из дискретного распределения Гаусса). Предоставляемая информация представляет собой список пар случайных векторов $\mathbf{a}_i$ и $b_i$, вычисленных с добавлением этой ошибки. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Это можно очень элегантно выразить в матричной форме. Используя случайную матрицу $A \in \mathbb{Z}_q^{m \times n}$, секретный вектор $\mathbf{s} \in \mathbb{Z}_q^n$ и вектор ошибки $\mathbf{e} \in \mathbb{Z}_q^m$, мы можем записать:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

Нам даны только $A$ и $\mathbf{b}$. Процесс поиска $\mathbf{s}$ на их основе называется “проблемой поиска LWE” (Search LWE problem).

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

4.3 Проблема решения LWE (Decision LWE)

В криптографических доказательствах часто используется вариация задачи поиска LWE, называемая “проблемой решения LWE” (Decision LWE problem).

Задача решения LWE состоит в том, чтобы, получив список образцов из следующих двух распределений, определить, из какого распределения они получены:

Распределение LWE: Намеренно вычисленное $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
Равномерное случайное распределение: $(A, \mathbf{u})$, состоящее из совершенно случайно выбранной матрицы $A$ и вектора $\mathbf{u}$

Удивительно, но если параметры проблемы LWE выбраны правильно, пары, полученные из распределения LWE, становятся “вычислительно неразличимыми” (Computationally Indistinguishable) от полностью случайных пар данных. Это свойство является основой того, что криптография на базе LWE может генерировать “шифротексты, неотличимые от случайных чисел”.

4.4 Сведение от сложности в худшем случае к сложности в среднем случае (Теорема Регева)

Величайшим достижением Одеда Регева было математическое связывание сложности этой проблемы LWE со сложностью вышеупомянутых задач на решетках (SVP и CVP).

Используя квантовое сведение (Quantum reduction), он доказал, что: “Если существует алгоритм полиномиального времени, который может решить проблему LWE в среднем (для случайно выбранных $A$ и $\mathbf{e}$), то существует квантовый алгоритм полиномиального времени, который может решить Gap-SVP в худшем случае (самый сложный случай) для любой решетки”. (Позже Пейкерт (Peikert) и другие также продемонстрировали классическое сведение).

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

graph TD A["Худший случай задач на решетках (Gap-SVP, SIVP)"] -->|Квантовое/Классическое сведение| B["Проблема LWE в среднем случае"] B -->|Криптографическая конструкция| C["Криптосистемы на основе LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Построение криптографии с открытым ключом с использованием LWE (Криптосистема Регева)

Поняв сложность проблемы LWE, давайте посмотрим на базовую криптосистему с открытым ключом, предложенную Одедом Регевом, чтобы увидеть, как с ее помощью выполняются шифрование и дешифрование. Здесь мы объясним самый основной механизм шифрования 1-битного сообщения $M \in \{0, 1\}$.

5.1 Генерация ключей (Key Generation)

Определяются системные параметры: простое число $q$, размерность $n$ и количество уравнений $m$ ($m > n \log q$).
В качестве секретного ключа случайно выбирается вектор $\mathbf{s} \in \mathbb{Z}_q^n$.
Генерируется случайная матрица $A \in \mathbb{Z}_q^{m \times n}$.
Малый вектор ошибки $\mathbf{e} \in \mathbb{Z}_q^m$ выбирается из распределения ошибок, например, дискретного гауссовского.
Вычисляется вектор $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
Открытый ключ (Public Key) — это $(A, \mathbf{b})$.
Секретный ключ (Secret Key) — это $\mathbf{s}$.

Открытый ключ - это буквально “экземпляр проблемы LWE”. Поиск секретного ключа $\mathbf{s}$ по открытому ключу $(A, \mathbf{b})$ эквивалентен решению задачи поиска LWE, поэтому безопасность гарантирована.

5.2 Шифрование (Encryption)

Алиса использует открытый ключ Боба $(A, \mathbf{b})$ для шифрования 1-битного сообщения $M \in \{0, 1\}$.

Выбирается случайный бинарный вектор (с компонентами 0 или 1) $\mathbf{r} \in \{0, 1\}^m$.
В качестве первой части шифротекста вычисляется вектор $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ - транспонированная матрица $A$. Это означает, что мы суммируем те строки $A$, для которых компоненты $\mathbf{r}$ равны 1).
В качестве второй части шифротекста вычисляется скаляр $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Если сообщение $M$ равно 0, ничего не добавляется; если $1$, добавляется ровно половина значения $q$, то есть $\lfloor \frac{q}{2} \rfloor$).
Шифротекст (Ciphertext) представляет собой $(\mathbf{u}, v)$.

Интуитивный смысл шифрования заключается во взятии “суммы случайного подмножества” для матрицы открытого ключа $A$ и вектора $\mathbf{b}$. Из-за сложности проблемы решения LWE этот шифротекст $(\mathbf{u}, v)$ выглядит неотличимым от полностью случайного вектора и равномерного случайного числа (семантическая безопасность: Semantic Security).

flowchart LR M["Сообщение M в {0,1}"] --> Enc PK["Открытый ключ (A, b)"] --> Enc r["Случайный бинарный вектор r"] --> Enc subgraph Enc ["Процесс шифрования"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Шифротекст (u, v)"]

5.3 Дешифрование (Decryption)

Боб расшифровывает шифротекст $(\mathbf{u}, v)$, используя свой секретный ключ $\mathbf{s}$.

Он вычисляет следующее значение: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Если вычисленный результат ближе к $0$, выводится $M=0$; если он ближе к $\lfloor \frac{q}{2} \rfloor$, выводится $M=1$.

Давайте математически раскроем это, чтобы понять, почему оно может быть расшифровано. Вспомните, что $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Здесь $\mathbf{s}^T A^T \mathbf{r}$ аккуратно компенсируется и исчезает из уравнения! Остается только $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ - это вектор шума с очень маленькими компонентами, а $\mathbf{r}$ - бинарный вектор с компонентами 0 или 1. Следовательно, их скалярное произведение $\mathbf{e}^T \mathbf{r}$ также останется относительно небольшим значением (если параметры выбраны правильно).

Если $M=0$, то результат будет равен $\mathbf{e}^T \mathbf{r}$, что является малым значением, близким к $0$.
Если $M=1$, то результат будет равен $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, что будет расположено вокруг половины значения $q$, то есть $\lfloor \frac{q}{2} \rfloor$.

Если параметры спроектированы так, что абсолютное значение ошибки $\mathbf{e}^T \mathbf{r}$ находится в пределах $\frac{q}{4}$, Боб может точно определить (расшифровать) сообщение $M$, просто посмотрев, к чему ближе результат вычислений: к $0$ или к $\lfloor \frac{q}{2} \rfloor$. Это прекрасный механизм, благодаря которому работает криптография на базе LWE.

flowchart LR CT["Шифротекст (u, v)"] --> Dec SK["Секретный ключ s"] --> Dec subgraph Dec ["Процесс дешифрования"] direction TB calc["Вычислить D = v - s^T * u mod q"] check["Проверить, ближе ли D к 0 или q/2"] end calc --> check Dec --> M_out["Восстановленное сообщение M"]

6. Игрушечный пример LWE-шифрования с конкретными числами

Я думаю, что трудно прочувствовать это только с помощью ряда формул, поэтому давайте фактически проследим вычисления от шифрования до дешифрования, установив очень маленькие числовые параметры. (В реальных криптографических системах для обеспечения безопасности используются значения $n$ от 500 и выше, и $q$ от нескольких тысяч и выше)

[Установка параметров]

Модуль $q = 17$ (Простое число. Таким образом, значения принимаются в диапазоне от $0$ до $16$)
Размерность $n = 2$
Количество уравнений $m = 4$
Предположим, мы шифруем сообщение $M = 1$.
Величина сдвига сообщения: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Фаза генерации ключей] Боб случайным образом выбирает секретный ключ $\mathbf{s}$, матрицу $A$ и вектор ошибки $\mathbf{e}$.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Далее вычисляется открытый ключ $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Мы вычисляем это по модулю 17. (Например, $66 = 17 \times 3 + 15$)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Мы прибавляем вектор ошибки $\mathbf{e}$.

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

Открытый ключ состоит из $A$ и $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Фаза шифрования] Алиса шифрует сообщение $M = 1$. Она выбирает случайный вектор $\mathbf{r}$. Пусть $\mathbf{r} = (1, 0, 1, 0)^T$.

Вычисляется $\mathbf{u}$.

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Вычисляется $v$.

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Прибавляется значение, соответствующее сообщению $M=1$: $\lfloor 17/2 \rfloor = 8$.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Алиса отправляет Бобу шифротекст $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$.

[3. Фаза дешифрования] Боб, получивший шифротекст, расшифровывает его с помощью секретного ключа $\mathbf{s} = (3, 4)^T$. Он вычисляет формулу процесса дешифрования: $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Здесь, в мире по модулю 17, $-8$ равно $9$ ($-8 + 17 = 9$). Полученное значение $D = 9$ проверяется, к чему оно ближе: к $0$ или к $8$ ($\lfloor 17/2 \rfloor$). Поскольку $9$ явно ближе к $8$, чем к $0$, Боб смог правильно восстановить $M = 1$!

Почему получилось $9$? Давайте вспомним доказательство, приведенное ранее. Часть ошибки равна $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Следовательно, результат вычислений равен $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, и мы убедились, что теоретическое значение было вычислено правильно.

7. Эволюция к практическому применению: Ring-LWE и Module-LWE

Стандартная проблема LWE (Standard LWE), которую мы объясняли до сих пор, имеет очень сильное доказательство безопасности, но на практике у нее есть фатальные недостатки: “огромный размер ключа” и “высокая вычислительная стоимость”.

В Standard LWE открытый ключ включает огромную матрицу $A \in \mathbb{Z}_q^{m \times n}$. Когда параметр $n$ достигает сотен или тысяч, размер этой матрицы достигает нескольких мегабайт, что слишком тяжело для передачи и приема каждый раз в интернет-протоколах связи (таких как TLS). Кроме того, умножение матрицы на вектор требует сложности вычислений $\mathcal{O}(n^2)$.

Для решения этой проблемы были внедрены “Ring-LWE (RLWE)” и “Module-LWE (MLWE)”, которые включают алгебраическую структуру, называемую кольцами многочленов (Polynomial rings), в решетку.

7.1 Интуиция Ring-LWE

В Ring-LWE векторы и матрицы заменяются на элементы (многочлены) над кольцом многочленов $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Здесь $n$ выбирается как степень двойки).

В то время как открытым ключом в Standard LWE была матрица $A$, Ring-LWE использует один многочлен $a(x)$. Секретный ключ $s(x)$ и ошибка $e(x)$ также становятся многочленами. Уравнение выглядит следующим образом:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Поскольку это умножение многочленов, за счет использования “теоретико-числового преобразования (Number Theoretic Transform: NTT)”, аналогичного быстрому преобразованию Фурье (FFT), вычислительная сложность может быть резко снижена до $\mathcal{O}(n \log n)$. Кроме того, поскольку размер открытого ключа уменьшается с матрицы до одного многочлена, размер данных сокращается до $\mathcal{O}(n)$. Это дает подавляющее преимущество в пропускной способности связи.

С математической точки зрения Ring-LWE сводится к задаче на решетке с особой симметрией, называемой “идеальной решеткой” (Ideal Lattice), а не на общей решетке.

7.2 Module-LWE и стандартизация NIST (Kyber / ML-KEM)

Хотя Ring-LWE эффективен, существовало некоторое опасение, что специальная алгебраическая структура идеальных решеток может стать отправной точкой для будущих атак. Поэтому “Module-LWE (MLWE)” был создан, чтобы взять “лучшее из обоих миров”: консервативную безопасность Standard LWE и эффективность Ring-LWE.

В Module-LWE мы рассматриваем небольшие матрицы и векторы, элементами которых являются многочлены. Другими словами, мы работаем с модулями над кольцом. В настоящее время “CRYSTALS-Kyber” (название стандарта: ML-KEM), выбранный NIST в качестве стандарта алгоритма инкапсуляции ключей (KEM) для PQC, построен именно на сложности этой проблемы Module-LWE.

8. Почему это безопасно против квантовых компьютеров?

Наконец, мы коснемся сути вопроса: “Почему считается, что криптография на решетках не может быть взломана даже с помощью квантовых компьютеров?”

Алгоритм Шора, с помощью которого квантовые компьютеры взламывают шифрование RSA и криптографию на эллиптических кривых, по сути, является алгоритмом для решения “проблемы скрытой подгруппы (Hidden Subgroup Problem: HSP)”. Математическая структура (конечные абелевы группы), лежащая в основе RSA и ECC, обладает периодичностью, и эта периодичность (скрытая подгруппа) может быть извлечена за один шаг путем использования специальной операции квантового алгоритма, называемой квантовым преобразованием Фурье (QFT).

Однако задачи на решетках в корне отличаются. Решетки также имеют периодичность, но то, что ищется в SVP и CVP, — это геометрические нелинейные свойства, такие как “кратчайшее расстояние” и “удаление шума”. Даже если применить “квантовое преобразование Фурье на абелевой группе”, подобно алгоритму Шора, непосредственно к задачам на решетках, полезную информацию для их решения нельзя эффективно извлечь. На сегодняшний день не было найдено квантовых алгоритмов, способных решить SVP или LWE за полиномиальное время. Широко распространено мнение, что даже с мощью параллельных вычислений квантовых компьютеров единственным эффективным средством является поиск, близкий к полному перебору (ускорение в виде квадратного корня с помощью алгоритма Гровера).

9. Заключение

В этой статье мы подробно рассмотрели математическую интуицию криптографии на решетках, начиная с геометрического определения решеток, переходя к формулировке проблемы LWE и заканчивая построением криптографии с открытым ключом.

Решетка (Lattice) — это дискретное пространство, представленное линейными комбинациями базисных векторов с целыми коэффициентами, и в высоких измерениях становится трудно найти “хороший базис”, близкий к ортогональному (SVP).
Проблема LWE (Learning With Errors) — это проблема решения систем линейных уравнений с шумом. Поскольку она связана со сложностью задач на решетках в худшем случае, это обеспечивает сильное доказательство безопасности.
Используя проблему LWE, шифрование и дешифрование (Криптосистема Регева) реализуются с помощью хитроумного механизма намеренного добавления или удаления шума.
В реальных протоколах для повышения эффективности связи и скорости вычислений используются Ring-LWE и Module-LWE с кольцами многочленов, которые служат основой для стандарта NIST ML-KEM.

В условиях надвигающегося беспрецедентного сдвига вычислительной парадигмы в виде квантовых компьютеров весьма романтично думать, что “криптография на решетках”, родившаяся из глубин классической линейной алгебры и теории чисел, сформирует основу будущей интернет-безопасности. Математика, лежащая в основе криптографии на решетках, не является чрезмерно сложной, и ее красивую структуру можно полностью понять, обладая базовыми знаниями в области линейной алгебры и теории вероятностей. Мы надеемся, что эта статья поможет вам понять криптографию на решетках, которая является ядром PQC.

Механизм доказательства с нулевым разглашением (ZKP) и его последние применения в Web3 и безопасности

Fri, 11 Sep 2026 19:00:00 +0900

Введение

В современном цифровом обществе конфиденциальность данных и масштабируемость стали двумя наиболее важными проблемами. По мере роста риска утечек и несанкционированного использования личной информации, возникает острая необходимость в технологии, позволяющей «доказать, что вы обладаете определенной информацией, не раскрывая саму эту информацию другой стороне». Именно это и реализует доказательство с нулевым разглашением (Zero-Knowledge Proof: ZKP).

Доказательство с нулевым разглашением — это криптографическая концепция, впервые предложенная в 1980-х годах Шафи Гольдвассер, Сильвио Микали и Чарльзом Ракоффом, однако долгое время она оставалась лишь предметом теоретических исследований. Но с появлением технологии блокчейн и Web3 ситуация кардинально изменилась. ZKP оказалось в центре внимания как «волшебная палочка», способная одновременно решить проблему масштабируемости (ограничения пропускной способности) и проблему конфиденциальности (все транзакции публичны), с которыми сталкиваются публичные блокчейны, такие как Ethereum.

В этой статье мы подробно и глубоко с технической точки зрения рассмотрим основные концепции доказательства с нулевым разглашением, глубокие математические и криптографические механизмы zk-SNARKs и zk-STARKs, которые в настоящее время являются основными, а также последние примеры их применения в Web3 и сфере безопасности, такие как ZK-Rollups и децентрализованная идентификация (DID).

Что такое доказательство с нулевым разглашением (ZKP)?

Доказательство с нулевым разглашением (ZKP) означает протокол, при котором доказывающий (Prover) доказывает проверяющему (Verifier), что некое утверждение истинно, но при этом «не передает абсолютно никакой информации, кроме самого факта истинности этого утверждения».

3 требования, которым должно удовлетворять ZKP

Чтобы считаться ZKP, протокол должен строго выполнять следующие три свойства:

Полнота (Completeness) Если утверждение истинно, и доказывающий с проверяющим добросовестно следуют протоколу, проверяющий должен принять доказательство (Accept) с подавляющей вероятностью.
Корректность (Soundness) Если утверждение ложно, то никакой доказывающий-злоумышленник, какими бы вычислительными мощностями он ни обладал, не сможет обмануть проверяющего и заставить его принять доказательство (за исключением пренебрежимо малой вероятности).
Нулевое разглашение (Zero-Knowledge) Если утверждение истинно, проверяющий не может получить из процесса доказательства никакой другой информации, кроме того факта, что «утверждение истинно». С точки зрения проверяющего, это доказывается математическим определением того, что процесс доказательства можно смоделировать (существует симулятор).

Интерактивные и неинтерактивные доказательства

ZKP делится на два типа: интерактивное доказательство, при котором доказывающий и проверяющий обмениваются сообщениями несколько раз, и неинтерактивное доказательство, при котором доказывающий отправляет данные доказательства только один раз.

Интерактивное доказательство (Interactive ZKP)

Ранние ZKP разрабатывались как интерактивные протоколы. Известная притча о «пещере Али-Бабы» является примером такого подхода. Основной поток протокола выглядит следующим образом:

sequenceDiagram participant Prover as "Prover (Доказывающий)" participant Verifier as "Verifier (Проверяющий)" Note over Prover, Verifier: "Основной процесс интерактивного доказательства" Prover->>Verifier: "1. Отправить обязательство (Commitment)" Verifier->>Prover: "2. Отправить случайный вызов (Challenge)" Prover->>Verifier: "3. Вычислить и отправить ответ (Response)" Note over Verifier: "Проверить ответ (Verification)" Verifier-->>Prover: "4. Принять или отклонить (Accept / Reject)" Note over Prover, Verifier: "※Для повышения достоверности это повторяется десятки раз"

Этот метод эффективен, но требует, чтобы проверяющий находился онлайн, что делает его неудобным для применения в асинхронных распределенных системах, таких как блокчейн. В блокчейне любой желающий должен иметь возможность в любое время проверить прошлые доказательства.

Эвристика Фиата-Шамира (Fiat-Shamir Heuristic) и переход к неинтерактивности

Революционным методом преобразования интерактивных доказательств в неинтерактивные (Non-Interactive Zero-Knowledge Proof: NIZK) является преобразование (эвристика) Фиата-Шамира.

Вместо «случайного вызова», отправляемого проверяющим, доказывающий самостоятельно генерирует «псевдослучайный вызов», используя собственное обязательство (commitment) и хеш-значение публичной информации. При условии, что криптографическая хеш-функция (например, SHA-256 или Keccak) работает как случайный оракул (Random Oracle), доказывающий не может заранее предсказать или манипулировать вызовом. Таким образом, доказательство завершается одной отправкой сообщения с сохранением безопасности, эквивалентной интерактивному доказательству.

Технические подробности zk-SNARKs

В настоящее время наиболее широко используемым видом ZKP является zk-SNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge). Как следует из названия, это аргумент знания (Argument of Knowledge), который обладает нулевым разглашением (zk), имеет очень маленький размер доказательства и быстро проверяется (Succinct), а также является неинтерактивным (Non-Interactive).

В основе zk-SNARKs лежит передовая алгебраическая геометрия и криптография. Они преобразуют выполнение программ и вычисления в проверку уравнений определенных многочленов.

1. Арифметические схемы и преобразование в R1CS (Rank-1 Constraint System)

Сначала любое вычисление, которое необходимо доказать (алгоритм или логика смарт-контракта), преобразуется в арифметическую схему (Arithmetic Circuit), состоящую из вентилей сложения и умножения.

Затем эта арифметическая схема преобразуется в набор матричных уравнений, называемый R1CS (Rank-1 Constraint System). R1CS — это задача поиска матриц $A, B, C$, удовлетворяющих следующему ограничению для вектора переменных $x$:

$$ (A \cdot x) \circ (B \cdot x) = C \cdot x $$

Здесь $\circ$ обозначает произведение Адамара (поэлементное умножение). Это ограничение гарантирует, что все логические вентили в схеме (особенно вентили умножения) вычислены правильно.

2. Преобразование в QAP (Quadratic Arithmetic Program)

Поскольку матричных ограничений R1CS существует огромное количество, проверять их по отдельности крайне неэффективно. Поэтому с помощью интерполяции Лагранжа эти ограничения сжимаются в единое полиномиальное уравнение. Это называется QAP (Quadratic Arithmetic Program).

За счет преобразования в QAP задача, которую необходимо доказать, сводится к вопросу: «Делится ли определенный многочлен $P(x)$ на другой известный многочлен $Z(x)$?»

$$ P(x) = L(x) \cdot R(x) - O(x) $$

Здесь $L(x), R(x), O(x)$ — многочлены, составленные из соответствующих строк матриц $A, B, C$. Если доказывающий знает правильное решение (Witness), значение $P(x)$ будет равно 0 в каждом корне (точке оценки), поэтому $P(x)$ будет иметь целевой многочлен $Z(x)$ в качестве множителя. То есть существует некоторый многочлен $H(x)$, для которого выполняется:

$$ P(x) = H(x) \cdot Z(x) $$

Проверяющий может мгновенно проверить правильность выполнения всего вычисления, просто проверив, выполняется ли это уравнение $P(s) = H(s) \cdot Z(s)$ в некоторой случайной секретной точке $s$. В этом заключается секрет «Succinct» (краткости).

3. Эллиптическая криптография и спаривание (Bilinear Pairings)

Однако, если бы проверяющий знал секретную точку $s$, доказывающий мог бы подделать ложный многочлен для удовлетворения уравнения (нарушение корректности). Поэтому вычисления необходимо проводить, пока $s$ остается зашифрованным от всех (с использованием гомоморфного шифрования).

Это достигается с помощью эллиптического спаривания (Bilinear Pairings). Спаривание $e$ — это специальная функция, которая из двух зашифрованных значений позволяет вычислить значение, эквивалентное шифрованию их произведения.

$$ e(g_1^a, g_2^b) = e(g_1, g_2)^{ab} $$

Доказывающий, не зная самой $s$, использует зашифрованные значения степеней $s$ (это называется CRS: Common Reference String) для вычисления зашифрованных значений многочленов $P(s)$ и $H(s)$. Проверяющий использует функцию спаривания, чтобы проверить выполнение отношения $P(s) = H(s) \cdot Z(s)$, оперируя при этом зашифрованными значениями.

4. Доверенная установка (Trusted Setup)

Главной слабостью zk-SNARKs (особенно ранних версий, таких как Groth16) является необходимость процесса генерации секретной точки $s$, так называемой доверенной установки (Trusted Setup). Если создатель $s$ сохранит это значение вместо того, чтобы уничтожить его, он сможет сгенерировать любые ложные доказательства (проблема Toxic Waste).

Для предотвращения этого проводится ритуал, называемый «Ceremony», с использованием многосторонних вычислений (Multi-Party Computation, MPC). В нем участвует множество участников, предоставляя случайные данные. Если хотя бы один участник честно уничтожит свое случайное значение, безопасность всей системы будет сохранена. Тем не менее, исследования по устранению этой зависимости продолжались долгие годы.

Технические подробности zk-STARKs

В качестве ответа на зависимость от доверенной установки и риск взлома эллиптической криптографии квантовыми компьютерами появились zk-STARKs (Zero-Knowledge Scalable Transparent Argument of Knowledge).

Разработанные Эли Бен-Сассоном (Eli Ben-Sasson) и его коллегами, STARKs обладают характеристиками, отраженными в их названии: они «прозрачны» (Transparent) и вообще не требуют доверенной установки, а также «масштабируемы» (Scalable), поскольку размер доказательства и время проверки остаются эффективными даже при увеличении объема вычислений.

1. Полиномиальные обязательства и протокол FRI

В отличие от zk-SNARKs, zk-STARKs не используют эллиптическую криптографию, а основывают свою безопасность исключительно на хеш-функциях. Благодаря этому они обладают свойствами постквантовой криптографии (Post-Quantum Cryptography).

Проверка вычислений выполняется после их преобразования в формат под названием AIR (Algebraic Intermediate Representation) с использованием свойств одномерных или многомерных полиномов. Сердцем STARKs является протокол FRI (Fast Reed-Solomon Interactive Oracle Proof of Proximity).

Протокол FRI — это технология проверки того, «насколько близка определенная функция к полиному определенной степени» (Proximity). Доказывающий фиксирует значения полинома в качестве листьев дерева Меркла (Merkle Tree) (это называется полиномиальным обязательством).

graph TD Root["Корень Меркла (Обязательство)"] --> Node0["Узел 0"] Root --> Node1["Узел 1"] Node0 --> Leaf0["P(x_0)"] Node0 --> Leaf1["P(x_1)"] Node1 --> Leaf2["P(x_2)"] Node1 --> Leaf3["P(x_3)"]

Проверяющий запрашивает раскрытие нескольких случайных точек и использует доказательства Меркла (Merkle proof), чтобы подтвердить, что они включены в обязательство. Рекурсивно повторяя этот процесс, он с подавляющей вероятностью гарантирует, что степень исходного многочлена действительно низкая.

Сравнение zk-SNARKs и zk-STARKs

Характеристика	zk-SNARKs	zk-STARKs
Криптографические предположения	Эллиптические кривые, спаривание	Криптографические хеш-функции, устойчивые к коллизиям
Доверенная установка	Требуется (в Plonk и др. — универсальная)	Не требуется (Transparent)
Квантовая устойчивость	Нет	Есть
Размер доказательства	Очень маленький (~200 байт)	Довольно большой (десятки КБ)
Вычислительные затраты на создание доказательства	Высокие	Относительно ниже, чем у SNARKs
Затраты на проверку (Gas)	Очень низкие (постоянные)	Низкие (логарифмический рост)

В последние годы появились SNARKs, такие как Plonk и Halo2, которым «не требуется доверенная установка или она нужна только один раз», поэтому граница между SNARKs и STARKs постепенно стирается, но принципиальная разница в математическом подходе остается важной.

Новейшие применения доказательства с нулевым разглашением в Web3 и безопасности

Перейдя от теории к практике, ZKP в настоящее время производит революцию на переднем крае Web3 и кибербезопасности.

1. Максимальное масштабирование Ethereum с помощью ZK-Rollups

Блокчейны уровня 1 (L1), такие как Ethereum, придают большое значение децентрализации и безопасности, но из-за этого имеют серьезные ограничения масштабируемости (трилемма). Окончательным решением уровня 2 (L2), устраняющим эту проблему, являются ZK-Rollups.

В ZK-Rollup тысячи транзакций выполняются и обрабатываются вне сети (L2), и генерируется «одно ZKP (Validity Proof)», подтверждающее правильность их выполнения. Смарт-контракту в блокчейне L1 остается только проверить это доказательство.

flowchart LR Users["Пользователи (Отправка Tx)"] --> Sequencer["Секвенсор (Сбор и выполнение Tx)"] Sequencer --> Prover["Доказывающий (Генерация ZKP)"] Sequencer --> L1Contract["L1 Смарт-контракт (Публикация данных Tx)"] Prover --> L1Contract["Предоставление ZKP (Доказательства)"] L1Contract --> Verify["Проверка и обновление состояния"]

Главным преимуществом ZK-Rollups, в отличие от Optimistic Rollups (например, Arbitrum или Optimism), является отсутствие необходимости в периоде оспаривания (challenge period, обычно 7 дней) для доказательства мошенничества (Fraud Proof). Поскольку правильность криптографически гарантирована, как только доказательство проверено, вывод средств (Finality) на L1 завершается мгновенно. В настоящее время такие проекты, как zkSync, Starknet, Scroll и Polygon zkEVM, ведут ожесточенную конкуренцию в разработке, и реализация zkEVM, совместимой с EVM (виртуальной машиной Ethereum), способствует быстрому росту экосистемы.

2. Идентификация с сохранением конфиденциальности (ZKP for Identity)

ZKP также в корне меняет способы личной аутентификации в цифровом мире. Например, на вопрос «Вам больше 18 лет?» в традиционных системах мы показываем водительские права или паспорт, передавая собеседнику ненужную личную информацию, такую как имя или адрес.

Используя ZKP, на основе цифрового сертификата (Verifiable Credential), выданного государственным органом, можно математически доказать только тот факт, что «согласно моей дате рождения, на текущую дату мне больше 18 лет». Проверяющему достаточно проверить подпись сертификата и ZKP, и он не сможет узнать вашу дату рождения или личность.

Проекты «доказательства личности» (Proof of Personhood), такие как Worldcoin, также не хранят и не передают данные радужной оболочки глаза напрямую. Вместо этого они используют ZKP, чтобы доказать только то, что «вы — уникальный человек».

3. Конфиденциальные смарт-контракты и корпоративное использование

Свойство публичных блокчейнов, при котором «все данные открыты», было серьезным препятствием для компаний при работе с конфиденциальными транзакциями или информацией о цепочках поставок в блокчейне.

Используя технологии ZKP (например, сети, ориентированные на конфиденциальность, такие как Aleo или Aztec), можно записывать в публичный блокчейн только подтверждение правильности обновления состояния, оставляя входные и выходные значения транзакций и даже саму логику выполняемого смарт-контракта в зашифрованном виде. Это позволяет предотвратить фронтраннинг (MEV) в DeFi (децентрализованных финансах) и создать конфиденциальные сети консорциумов между компаниями, наслаждаясь при этом высокой безопасностью публичных блокчейнов.

Будущие проблемы и перспективы ZKP

ZKP, несомненно, является фундаментальной технологией следующего поколения, но остаются и некоторые проблемы.

Вычислительные затраты на генерацию доказательств и аппаратное ускорение Генерация ZKP требует огромного количества полиномиальных операций, быстрого преобразования Фурье (FFT) и мультискалярного умножения (MSM). В настоящее время быстро продвигаются исследования в области разработки специализированного аппаратного обеспечения (FPGA или ASIC) для ускорения генерации доказательств, так называемый майнинг ZKP (Prover Network).
Стандартизация и улучшение опыта разработчиков (DX) Появилось множество специализированных языков для написания схем ZKP, таких как Circom, Cairo, Noir, Leo и другие. Зрелость компиляторов, которые автоматически генерируют схемы ZKP из существующих языков, таких как Rust или C++, и единые стандарты, объединяющие их, станут ключом к внедрению ZKP обычными инженерами-программистами.

Заключение

Доказательство с нулевым разглашением (ZKP) превратилось из просто «технологии повышения анонимности криптовалют» в «универсальную технологию, переопределяющую доверие во всем интернете». Небольшие доказательства, вычисленные в глубинах формул и криптографии, станут щитом, который бесконечно расширяет масштабируемость блокчейна и надежно защищает нашу конфиденциальность.

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

Источники и полезные ссылки

Groth, J. (2016). “On the Size of Pairing-based Non-interactive Arguments”
Ben-Sasson, E., et al. (2018). “Scalable, transparent, and post-quantum secure computational integrity”
Vitalik Buterin’s blog on zk-SNARKs and zk-STARKs

Гипотеза Римана и распределение простых чисел: глубокая связь с современной криптографией

Fri, 11 Sep 2026 16:00:00 +0900

1. Введение: Тайна простых чисел во Вселенной и гипотеза Римана

«Простые числа» (Prime Numbers) — это натуральные числа, которые делятся только на 1 и на сами себя. В мире математики их часто называют «атомами». Эта последовательность, 2, 3, 5, 7, 11, 13…, на первый взгляд кажется хаотичной и случайной. С тех пор как древнегреческий математик Евклид доказал, что «простых чисел бесконечно много», бесчисленное множество математиков пытались разгадать закономерности, скрывающиеся в этом ряду.

Ближе всего к разгадке тайны простых чисел подошла «Гипотеза Римана» (Riemann Hypothesis), предложенная немецким математиком Бернхардом Риманом в 1859 году. Гипотеза Римана является одной из самых важных и нерешенных проблем в современной математике. Она также включена в список Задач тысячелетия Института Клэя, за решение которой назначена награда в 1 миллион долларов.

На первый взгляд может показаться, что сложная проблема чистой математики, касающаяся распределения простых чисел, не имеет ничего общего с нашей повседневной жизнью. Однако безопасность инфраструктуры современного общества, в особенности интернета, опирается на современные криптографические технологии, такие как шифрование RSA и криптография на эллиптических кривых (ECC), которые глубоко зависят от свойств огромных простых чисел.

В этой статье мы совершим математическое путешествие: от распределения простых чисел к теореме о распределении простых чисел, дзета-функции Римана и, наконец, к сути гипотезы Римана. Мы чрезвычайно подробно и глубоко рассмотрим, как всё это связано с современными криптографическими технологиями, и что произойдет с миром, если гипотеза Римана будет доказана.

2. Теорема о распределении простых чисел: Открытие Гаусса

Чтобы понять, как распределены простые числа, математики придумали функцию распределения простых чисел (Prime-counting function) $\pi(x)$, которая показывает «сколько простых чисел существует до заданного числа $x$».

Например:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

15-летний гениальный математик Карл Фридрих Гаусс, вычислив огромные таблицы простых чисел, обнаружил, что частота появления простых чисел убывает обратно пропорционально натуральному логарифму $\ln x$. Иными словами, он предположил, что вероятность найти простое число в окрестности числа $x$ составляет примерно $\frac{1}{\ln x}$.

Выражение этой идеи с помощью интеграла называется интегральным логарифмом (Logarithmic integral) $\text{Li}(x)$:

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

Предположение Гаусса было независимо доказано в 1896 году Жаком Адамаром и Шарлем Жан де ла Валле-Пуссеном, и утвердилось как Теорема о распределении простых чисел (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

Или же это можно приблизительно выразить следующим образом:

$$ \pi(x) \sim \frac{x}{\ln x} $$

Эта теорема показала, что на макроскопическом уровне простые числа распределены очень плавно и предсказуемо. Однако на микроскопическом уровне между $\pi(x)$ и $\text{Li}(x)$ всегда существует «погрешность», то есть «флуктуация». Именно природа этой флуктуации является величайшей загадкой, которую пытается разгадать гипотеза Римана.

3. Дзета-функция Римана и произведение Эйлера

Самым мощным оружием в анализе распределения простых чисел является дзета-функция Римана (Riemann Zeta Function). Изначально это был бесконечный ряд, определенный Леонардом Эйлером для вещественных чисел $s > 1$.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

Одно из величайших достижений Эйлера заключалось в том, что он доказал, что этот бесконечный ряд можно представить как бесконечное произведение по всем простым числам $p$. Это и есть Тождество Эйлера (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

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

Эта единственная формула стала мостом, соединившим математический анализ (бесконечные ряды и непрерывные функции) и теорию чисел (простые числа и дискретные числа). Изучение дзета-функции равносильно изучению распределения простых чисел.

4. Аналитическое продолжение и расширение на комплексную плоскость

Гениальность Римана заключалась в том, что он расширил переменную $s$ в функции $\zeta(s)$, которую Эйлер рассматривал только для вещественных чисел, до комплексного числа $s = \sigma + it$ (где $\sigma$ — действительная часть, а $t$ — мнимая часть).

Исходный бесконечный ряд сходится только при $\sigma > 1$, но Риман, используя метод «аналитического продолжения» (Analytic Continuation), расширил определение функции так, чтобы $\zeta(s)$ имела смысл на всей комплексной плоскости, за исключением полюса в точке $s = 1$.

Далее он вывел красивое функциональное уравнение (Functional equation), которому удовлетворяет дзета-функция.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Здесь $\Gamma(x)$ — гамма-функция. Это уравнение позволяет узнать свойства функции в левой полуплоскости на основе её свойств в правой полуплоскости.

Нули (Zeros of the Zeta Function)

Комплексные числа $s$, при которых значение дзета-функции становится равным 0, называются «нулями». Из функционального уравнения следует, что когда $s$ — отрицательное четное число ($-2, -4, -6, \dots$), значение $\sin(\pi s / 2)$ равно 0, поэтому $\zeta(s) = 0$. Они называются тривиальными нулями (Trivial zeros).

Однако для распределения простых чисел важны другие нули — те, что находятся в «критической полосе» (Critical strip) $0 \le \sigma \le 1$, так называемые нетривиальные нули (Non-trivial zeros).

5. Суть гипотезы Римана и явная формула

Риман вычислил несколько таких нулей и выдвинул одно поразительное предположение. Это и есть гипотеза Римана.

Гипотеза Римана (Riemann Hypothesis) Все нетривиальные нули дзета-функции Римана $\zeta(s)$ лежат на прямой, действительная часть которой равна $1/2$ ($\text{Re}(s) = 1/2$).

Эта прямая с действительной частью 1/2 называется «критической прямой» (Critical line).

graph TD A["Дзета-функция Римана ζ(s)"] --> B["Расширение на комплексную плоскость аналитическим продолжением"] B --> C["Тривиальные нули (s = -2, -4, -6 ...)"] B --> D["Нетривиальные нули (0 <= Re(s) <= 1)"] D --> E["Гипотеза Римана"] E --> F["Все нетривиальные нули лежат на Re(s) = 1/2"] F --> G["К доказательству предела погрешности распределения простых чисел"]

Почему гипотеза Римана так важна? Потому что нули дзета-функции полностью определяют распределение простых чисел.

Риман и более поздний математик фон Мангольдт вывели «явную формулу» (Explicit formula), которая точно описывает распределение простых чисел. Используя функцию Чебышёва $\psi(x)$, это можно выразить следующим образом:

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Здесь сумма берется по всем нетривиальным нулям $\rho$ дзета-функции. Главным членом является $x$ (что соответствует теореме о распределении простых чисел), а путем прибавления и вычитания волнообразных членов, зависящих от нулей $\rho$, восстанавливается точное ступенчатое распределение простых чисел. Можно сказать, что нетривиальные нули представляют собой «частоты (волны)» распределения простых чисел.

Если гипотеза Римана верна, и действительная часть всех нетривиальных нулей $\rho$ в точности равна $1/2$, то член погрешности в теореме о распределении простых чисел будет укладываться в минимально возможный теоретический диапазон.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

Другими словами, если гипотеза Римана истинна, это докажет, что простые числа распределены настолько «правильно и красиво», насколько мы только можем себе представить.

6. Неразрывная связь современных криптографических технологий и простых чисел

До этого момента мы находились в мире глубокой чистой математики, но именно эти свойства простых чисел фундаментально поддерживают современное цифровое общество. Ярким примером является криптография с открытым ключом, такая как шифрование RSA.

Безопасность любых коммуникаций, будь то оплата кредитной картой в интернете, передача паролей или электронные подписи в блокчейне, зависит от «простых чисел».

Как работает шифрование RSA

Безопасность RSA основана на математическом факте (задаче факторизации), что «очень сложно разложить большое составное число на простые множители».

Генерация ключей: Случайным образом выбираются два огромных простых числа $p$ и $q$ (например, по 2048 бит каждое). Они перемножаются для получения $N = p \times q$. Это $N$ становится частью открытого ключа. Используя функцию Эйлера $\phi(N) = (p-1)(q-1)$, генерируется закрытый ключ $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Шифрование и расшифрование: Открытый текст $M$ преобразуется в зашифрованный текст $C$ с использованием открытого ключа $e, N$.
$$ C \equiv M^e \pmod{N} $$
Расшифровать текст может только тот, кто обладает закрытым ключом $d$.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Открытый текст (Plaintext)"] --> B["Шифрование открытым ключом (e, N)"] B --> C["Зашифрованный текст (Ciphertext)"] C --> D["Расшифрование закрытым ключом (d)"] D --> E["Исходный открытый текст"] F["Злоумышленник (Attacker)"] -- "Попытка факторизации N" --> C F -.-> G["Без знания p и q вычислить d невозможно"]

Чтобы взломать шифр RSA, нужно найти (факторизовать) исходные простые числа $p$ и $q$ из гигантского числа $N$. Считается, что даже с использованием самых передовых на сегодня алгоритмов (таких как общий метод решета числового поля, GNFS) и суперкомпьютеров, разложение числа из сотен цифр займет время, намного превышающее возраст Вселенной.

7. Влияние гипотезы Римана на криптографические технологии

Так как же пересекаются «гипотеза Римана», находящаяся на вершине чистой математики, и «криптография»?

7.1. Алгоритмы генерации простых чисел (проверка на простоту) и Обобщенная гипотеза Римана (GRH)

Для работы шифрования RSA необходимо сначала сгенерировать огромные простые числа $p$ и $q$. Однако надежно и быстро определить, «является ли число простым», не так-то просто.

В настоящее время на практике применяется вероятностный алгоритм — тест простоты Миллера-Рабина (Miller-Rabin primality test). Этот алгоритм быстр, но существует крайне низкая вероятность того, что составное число будет ошибочно признано простым (так называемые «псевдопростые числа»).

Однако, если предположить, что «Обобщенная гипотеза Римана» (Generalized Riemann Hypothesis, GRH), которая распространяет гипотезу Римана на L-функции Дирихле, верна, то ситуация кардинально меняется. Если GRH истинна, математически гарантируется верхняя граница количества проверок в тесте Миллера-Рабина, и вероятностный алгоритм превращается в «детерминированный алгоритм полиномиального времени» (этот важный факт был известен еще до открытия теста простоты AKS).

Таким образом, гипотеза Римана (и ее обобщение) играет роль непосредственного гаранта того, «можно ли с абсолютной уверенностью и высокой скоростью генерировать гигантские простые числа», что является фундаментом для создания шифров.

7.2. Связь с алгоритмами факторизации

Знания о распределении простых чисел также необходимы при оценке вычислительной сложности алгоритмов взлома шифров (таких как общий метод решета числового поля). Многие алгоритмы факторизации опираются на распределение «гладких чисел» (Smooth numbers — чисел, имеющих только небольшие простые множители).

Чтобы точно оценить частоту появления гладких чисел, необходимо глубокое понимание распределения простых чисел. Здесь также используются методы аналитической теории чисел, напрямую связанные с дзета-функцией и гипотезой Римана. Если гипотеза Римана будет доказана, и погрешность распределения простых чисел будет полностью определена, станет возможным более точно установить пределы эффективности алгоритмов факторизации.

8. Если гипотеза Римана будет доказана, будут ли взломаны шифры?

В качестве городской легенды иногда можно услышать, что «если гипотеза Римана будет решена, шифрование RSA рухнет в одно мгновение», но математически это неверно.

Само доказательство гипотезы Римана не приведет к мгновенному появлению магического алгоритма, который радикально ускорит факторизацию. Гипотеза Римана — это теорема о макроскопической «закономерности распределения» простых чисел, она не сообщает напрямую о том, на какие именно простые числа делится конкретное число $N$ (локальные свойства).

Однако влияние не будет нулевым. В процессе доказательства гипотезы Римана с огромной вероятностью могут быть открыты «новые математические инструменты» и «неизвестные аналитические методы». Как показывает история, доказательство Великой теоремы Ферма или гипотезы Пуанкаре породило новые теории, которые привели к колоссальному скачку в математике в целом.

Если будут разработаны неизвестные ранее методы алгебраической геометрии или некоммутативной геометрии, позволяющие полностью манипулировать свойствами нулей дзета-функции Римана, нельзя исключать, что это в конечном итоге приведет к открытию революционного алгоритма факторизации (например, классического алгоритма, который снизит время вычислений до полиномиального). В этом смысле криптографы никогда не смогут отвести взгляд от того, что происходит вокруг гипотезы Римана.

Квантовые компьютеры и алгоритм Шора

Куда более прямой и реальной угрозой для криптографических технологий является не доказательство гипотезы Римана, а квантовые компьютеры. Опубликованный Питером Шором (Peter Shor) в 1994 году «алгоритм Шора» доказал, что при наличии достаточно мощного квантового компьютера факторизация может быть решена за полиномиальное время. Это фундаментально разрушит шифрование RSA и криптографию на эллиптических кривых.

В настоящее время по всему миру идет переход на постквантовую криптографию (Post-Quantum Cryptography, PQC) (например, криптографию на решетках), которую не смогут взломать даже квантовые компьютеры. Криптографические технологии, основанные на простых числах, возможно, подходят к концу своего золотого века, но математическая ценность самих простых чисел не будет утрачена никогда.

9. Заключение: Перекресток математической абстракции и реального мира

graph TD A["Исследования в чистой математике"] --> B["Разгадка гипотезы Римана"] B --> C["Полное понимание распределения простых чисел"] C --> D["Стремительное развитие теории чисел и алгебраической геометрии"] D -.-> E["Вероятность появления новых алгоритмов факторизации"] E -.-> F["Обновление оценки безопасности криптографических технологий"] A --> G["Прикладная математика и информатика"] G --> H["Оптимизация проверки на простоту и генерации шифров"] H --> F

Неустанные поиски простых чисел, ведущиеся со времен Древней Греции, благодаря гению Римана превратились в прекрасную симфонию на комплексной плоскости (нули дзета-функции). И поразительно, что этот кристалл чистейшей математики спустя столетия применяется как самый мощный щит, гарантирующий безопасность интернет-общества.

Гипотеза Римана символизирует одновременно «абстрактную красоту» математики и её «удивительную применимость в физическом мире и реальном обществе».

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

История криптографии: от шифра Цезаря до постквантовой криптографии (PQC)

Fri, 11 Sep 2026 15:00:00 +0900

1. Введение: Что такое криптография?

Криптография (Cryptography) — это технология сохранения конфиденциальности информации, которая развивалась вместе с историей человечества. От передачи секретных приказов на древних войнах до защиты данных кредитных карт в современном интернете, цель криптографии остается неизменной: “Сделать так, чтобы только предполагаемый получатель мог понять информацию, и чтобы третья сторона не смогла ее расшифровать”.

В современной информационной безопасности криптография играет важную роль, не ограничиваясь простой “секретностью информации (Конфиденциальность: Confidentiality)”, но и обеспечивая “целостность (Integrity)”, “аутентификацию (Authentication)” и “неотрекаемость (Non-repudiation)” данных.

В этой статье мы подробно рассмотрим историю развития криптографии с технологической и математической точек зрения, начиная с простых древних шифров замены, переходя к механическим шифрам, современной криптографии с симметричным и открытым ключом, и заканчивая эрой “постквантовой криптографии (PQC)”, которая наступит с практическим применением квантовых компьютеров.

2. Эпоха классической криптографии: Замена и перестановка символов

Происхождение криптографии восходит к временам до нашей эры. Ранние шифры в основном состояли из двух подходов: “перестановка” и “замена”.

Шифр Скитала (Шифр перестановки)

“Скитала” (Scytale), использовавшаяся в древней Греции в Спарте в 5 веке до н.э., является одним из старейших криптографических устройств. Длинная полоска пергамента наматывалась на деревянную палочку определенной толщины, и на ней писалось сообщение поперек. Когда пергамент разматывался, буквы оказывались в бессмысленном порядке, но получатель с палочкой такой же толщины мог снова намотать пергамент и прочитать исходное сообщение.

Шифр Цезаря (Шифр простой замены)

Шифр Цезаря — это шифр, который, как считается, использовал Юлий Цезарь, герой Древнего Рима в 1 веке до н.э. Это шифр моноалфавитной подстановки (Monoalphabetic substitution), который сдвигает алфавит на фиксированное количество позиций (обычно на 3 буквы).

Математически, если рассматривать буквы как числа от $0$ до $25$, а величину сдвига как $K$, преобразование исходного текста $P$ в зашифрованный текст $C$ выражается следующим уравнением по модулю:

$$C \equiv P + K \pmod{26}$$

Расшифровка выполняется обратной операцией:

$$P \equiv C - K \pmod{26}$$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Пример простой реализации шифра Цезаря на Python
def caesar_cipher(text, shift, mode="encrypt"):
 result = ""
 if mode == "decrypt":
 shift = -shift

 for char in text:
 if char.isalpha():
 base = ord('A') if char.isupper() else ord('a')
 # Вычисление сдвига
 result += chr((ord(char) - base + shift) % 26 + base)
 else:
 result += char
 return result

# Пример выполнения
plaintext = "HELLO WORLD"
ciphertext = caesar_cipher(plaintext, 3, "encrypt")
print(f"Зашифрованный текст: {ciphertext}") # KHOOR ZRUOG

Частотный анализ и шифр Виженера

Шифры моноалфавитной подстановки стали легко взламываться с помощью “частотного анализа” (Frequency Analysis), изобретенного арабским ученым Аль-Кинди в 9 веке. Он использует статистические особенности языка, например, то, что в английском языке буквы “E” и “T” встречаются чаще всего.

Чтобы противостоять этому, в 16 веке был изобретен “шифр Виженера” (Vigenère cipher). Это полиалфавитный шифр замены (Polyalphabetic substitution), который циклически переключает несколько сдвигов (ключей), и около 300 лет его называли “неразрешимым шифром” (Le Chiffre Indéchiffrable).

Математически $i$-я буква исходного текста $P_i$ и $i$-я буква повторяющегося ключа $K_i$ шифруются следующим образом:

$$C_i \equiv P_i + K_i \pmod{26}$$

Однако в 19 веке Чарльз Бэббидж и Фридрих Касиски открыли “метод Касиски” (Kasiski examination), который позволял определить длину ключа по повторяющимся паттернам в зашифрованном тексте, и шифр был взломан.

graph TD subgraph "Классификация классической криптографии" A["Классическая криптография"] --> B["Шифр перестановки"] A --> C["Шифр замены"] B --> D["Шифр Скитала"] C --> E["Моноалфавитная замена"] C --> F["Полиалфавитная замена"] E --> G["Шифр Цезаря"] F --> H["Шифр Виженера"] end

3. Механическая криптография и мировые войны: Энигма и ее расшифровка

В начале 20 века средства связи перешли от писем к телеграфу и радио, что потребовало увеличения скорости и сложности шифрования. В это время появилась “механическая криптография”, использующая комбинацию роторов (вращающихся дисков).

Угроза Энигмы (Enigma)

“Энигма”, использовавшаяся нацистской Германией во время Второй мировой войны, является самой известной шифровальной машиной в истории криптографии. Энигма состояла из нескольких роторов (обычно 3-4), коммутационной панели (Steckerbrett), меняющей проводку букв, и рефлектора (отражающего ротора).

Каждый раз при вводе буквы с клавиатуры ротор вращался, поэтому даже при последовательном вводе одной и той же буквы выводились разные зашифрованные символы (высшая форма полиалфавитного шифра). Пространство ключей (комбинаций настроек) составляло около $1.58 \times 10^{19}$ вариантов (около 15,8 квинтиллионов), и считалось, что взломать ее полным перебором при технологиях того времени было невозможно.

Алан Тьюринг и “Бомба” (Bombe)

Вызов этой неприступной Энигме бросила команда криптоаналитиков из Блетчли-парка в Великобритании, опираясь на ранние результаты польского математика Мариана Реевского и его коллег.

В частности, Алан Тьюринг (Alan Turing) использовал предположения об исходном тексте, соответствующем части зашифрованного текста (криб: Crib), и разработал электромеханическую машину для расшифровки, названную “Бомба” (Bombe). “Бомба” быстро обнаруживала логические противоречия и последовательно исключала невозможные настройки роторов, что позволило успешно расшифровать Энигму. Считается, что это великое достижение приблизило победу союзников на несколько лет.

4. Начало современной криптографии: Криптография с симметричным ключом (DES и AES)

После войны с появлением компьютеров шифрование претерпело радикальную смену парадигмы: от манипуляций с “символами” к операциям с “битами (0 и 1)”.

Клод Шеннон и теория информации

В 1949 году Клод Шеннон опубликовал работу “Теория связи в секретных системах”, заложив математические основы современной криптографии. Он предложил “запутывание” (Confusion) и “рассеивание” (Diffusion) в качестве принципов безопасного проектирования шифров.

Запутывание (Confusion): Сделать взаимосвязь между ключом и зашифрованным текстом как можно более сложной. (Реализуется через замену / S-блоки)
Рассеивание (Diffusion): Сделать так, чтобы изменение одного бита исходного текста влияло на множество битов зашифрованного текста. (Реализуется через перестановку / перемешивание)

DES (Data Encryption Standard)

В 1977 году Национальный институт стандартов и технологий США (NIST, тогда NBS) принял “DES”, основанный на дизайне IBM, в качестве стандартного шифра. DES использует архитектуру, называемую “Сеть Фейстеля” (Feistel Network), имеет размер блока 64 бита и длину ключа 56 бит. Это имело преимущество в реализации, так как алгоритмы шифрования и дешифрования имели почти одинаковую структуру.

Однако по мере роста вычислительных мощностей компьютеров стало ясно, что длины ключа в 56 бит (около $7.2 \times 10^{16}$ вариантов) недостаточно. В 1998 году Electronic Frontier Foundation (EFF) разработал специальную машину “Deep Crack”, которая смогла взломать DES за несколько дней.

AES (Advanced Encryption Standard)

В качестве нового стандарта, пришедшего на смену DES, в 2001 году был принят “AES”. Был выбран алгоритм “Rijndael”, разработанный бельгийскими криптографами по итогам открытого конкурса.

AES использует не Сеть Фейстеля, а “SPN-структуру” (Substitution-Permutation Network) и применяет математические операции в поле Галуа (конечном поле) $GF(2^8)$. Длину ключа можно выбрать из 128, 192 и 256 бит, и сегодня он широко используется по всему миру как стандартный симметричный алгоритм шифрования.

graph TD subgraph "1 раунд обработки AES (SPN-структура)" A["Состояние входа (128-bit)"] --> B("SubBytes (Байтовая замена / S-Box)") B --> C("ShiftRows (Сдвиг строк)") C --> D("MixColumns (Смешивание столбцов / Умножение в GF(2^8))") D --> E("AddRoundKey (XOR с раундовым ключом)") E --> F["Переход к следующему раунду"] end

5. Революция криптографии с открытым ключом: От Диффи-Хеллмана к RSA

Криптография с симметричным ключом имела существенный недостаток. Это “проблема распределения ключей” (Key Distribution Problem). Проблема заключалась в том, как безопасно разделить “общий ключ” с удаленным абонентом до начала зашифрованного общения. Эта проблема была решена в 1970-х годах с появлением “криптографии с открытым ключом”.

Обмен ключами Диффи-Хеллмана

В 1976 году Уитфилд Диффи и Мартин Хеллман опубликовали прорывную статью “Новые направления в криптографии”. Они предложили метод безопасного совместного использования ключа даже по прослушиваемому каналу связи, используя математическую сложность “задачи дискретного логарифмирования” (Discrete Logarithm Problem).

Публикуются большое простое число $p$ и генератор $g$.
Алиса выбирает секретное значение $a$ и отправляет Бобу $A = g^a \pmod{p}$.
Боб выбирает секретное значение $b$ и отправляет Алисе $B = g^b \pmod{p}$.
Алиса вычисляет $K = B^a \pmod{p}$, а Боб вычисляет $K = A^b \pmod{p}$.
По закону степеней $K = (g^b)^a = (g^a)^b = g^{ab} \pmod{p}$, и они успешно разделяют один и тот же ключ $K$.

Алгоритм RSA

В следующем 1977 году Рон Ривест, Ади Шамир и Леонард Адлеман изобрели “алгоритм RSA”. Он основан на том свойстве, что “разложение огромного составного числа на простые множители является сложным”.

Математический механизм RSA:

Выбираются два огромных простых числа $p$ и $q$, и вычисляется $n = p \times q$.
Вычисляется функция Эйлера $\phi(n) = (p-1)(q-1)$.
Выбирается целое число $e$ (открытый ключ), взаимно простое с $\phi(n)$.
Вычисляется целое число $d$ (закрытый ключ), такое что $e \times d \equiv 1 \pmod{\phi(n)}$.

Шифрование: Для исходного текста $M$ вычисляется $C \equiv M^e \pmod{n}$ Дешифрование: Для зашифрованного текста $C$ вычисляется $M \equiv C^d \pmod{n}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# Концептуальный код RSA на Python (не для практического использования)
def ext_euclid(a, b):
 # Вычисление модульного обратного с помощью расширенного алгоритма Евклида
 if b == 0: return 1, 0, a
 x, y, g = ext_euclid(b, a % b)
 return y, x - (a // b) * y, g

def rsa_example():
 # Пример с небольшими простыми числами
 p, q = 61, 53
 n = p * q
 phi = (p - 1) * (q - 1)

 e = 17 # Значение, взаимно простое с phi
 d, _, _ = ext_euclid(e, phi)
 if d < 0: d += phi

 print(f"Открытый ключ: (e={e}, n={n})")
 print(f"Закрытый ключ: (d={d}, n={n})")

 # Шифрование и расшифровка сообщения
 message = 65
 ciphertext = pow(message, e, n)
 decrypted = pow(ciphertext, d, n)

 print(f"Исходный текст: {message} -> Зашифрованный текст: {ciphertext} -> После расшифровки: {decrypted}")

rsa_example()

6. Расцвет криптографии на эллиптических кривых (ECC)

RSA — мощный алгоритм, но по мере роста производительности компьютеров возникла проблема увеличения вычислительных затрат из-за необходимости увеличивать длину ключа для поддержания безопасности (в настоящее время 2048 или 3072 бита).

Поэтому в 1985 году была предложена “криптография на эллиптических кривых” (Elliptic Curve Cryptography: ECC). Она использует сложение точек на эллиптической кривой (обычно вида $y^2 = x^3 + ax + b$) над конечным полем.

Известно, что задачу дискретного логарифмирования на эллиптической кривой (ECDLP) решить еще сложнее, чем задачу факторизации, и ECC может обеспечить уровень безопасности, эквивалентный 3072 битам RSA, при длине ключа всего 256 бит. Это позволило использовать быструю и безопасную зашифрованную связь (например, ECDSA и ECDH) даже в средах с ограниченными вычислительными ресурсами, таких как смартфоны и устройства IoT.

7. Угроза квантовых компьютеров и постквантовая криптография (PQC)

Казалось, что криптографические технологии непоколебимы, но алгоритм Шора (Shor’s algorithm), опубликованный Питером Шором в 1994 году, вызвал огромный шок.

Квантовые компьютеры выполняют вычисления, используя такие свойства квантовой механики, как “суперпозиция” и “квантовая запутанность”. Было математически доказано, что если выполнить алгоритм Шора на квантовом компьютере достаточной мощности, то задача факторизации и задача дискретного логарифмирования могут быть решены за “полиномиальное время”. Это означает, что в день появления практичного квантового компьютера (Q-Day) вся используемая сегодня криптография с открытым ключом, такая как RSA и ECC, мгновенно будет сломана.

Появление PQC (Post-Quantum Cryptography)

В ответ на эту беспрецедентную угрозу быстрыми темпами ведутся исследования в области “постквантовой криптографии” (PQC), основанной на новых математических задачах, которые трудно решить даже на квантовых компьютерах. NIST (Национальный институт стандартов и технологий США) в течение многих лет ведет процесс стандартизации PQC, и в основном рассматриваются следующие математические подходы.

1. Криптография на решетках (Lattice-based Cryptography)

В настоящее время это наиболее перспективный подход, который был принят в стандартах алгоритмов NIST (ML-KEM / Kyber, ML-DSA / Dilithium). Он основан на сложности задачи поиска определенной точки в многомерной “решетке” (Lattice) (например, задача поиска кратчайшего вектора: SVP) и задачи обучения с ошибками (Learning With Errors: LWE).

Концепция задачи LWE использует то свойство, что если намеренно добавить “небольшой шум (ошибку)” в систему линейных уравнений, найти решение становится чрезвычайно сложно. Система уравнений: $\mathbf{A}\mathbf{s} + \mathbf{e} \equiv \mathbf{b} \pmod{q}$ ($\mathbf{A}$ и $\mathbf{b}$ публичны, $\mathbf{s}$ — секретный ключ, $\mathbf{e}$ — небольшой шум)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# Концептуальный псевдокод задачи LWE (для обучения)
import numpy as np

n = 256 # Размерность
q = 3329 # Модуль
m = 512 # Количество уравнений

# Секретный ключ s и небольшая ошибка e
s = np.random.randint(0, 5, size=n)
e = np.random.randint(-1, 2, size=m)

# Публичная матрица A и публичный вектор b
A = np.random.randint(0, q, size=(m, n))
b = (np.dot(A, s) + e) % q

# Считается, что восстановить s из A и b очень сложно даже с использованием квантовых компьютеров

2. Криптография на основе хешей (Hash-based Cryptography)

Это схема цифровой подписи, безопасность которой основывается исключительно на стойкости хеш-функций к коллизиям. Поскольку она не имеет математической структуры, она устойчива к квантовым атакам, но размер подписи, как правило, получается большим (например, SPHINCS+).

3. Криптография на основе кодов (Code-based Cryptography)

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

timeline title "История эволюции криптографии и вычислительных машин" "Древность - Средние века" : "Шифр Цезаря" : "Шифр Виженера" : "Рождение частотного анализа" "1930-40-е годы" : "Использование и взлом Энигмы" : "Разработка машин Тьюринга и Бомбы" "1970-е годы" : "Стандартизация DES (1977)" : "Обмен ключами Диффи-Хеллмана (1976)" : "Создание алгоритма RSA (1977)" "1980-90-е годы" : "Предложение криптографии на эллиптических кривых (ECC)" : "Публикация алгоритма Шора (1994)" "2000-е годы" : "Стандартизация AES (2001)" "С 2010-х по настоящее время" : "Ускорение исследований квантовых компьютеров" : "Начало проекта стандартизации PQC от NIST" "Ближайшее будущее (Q-Day)" : "Создание крупномасштабного квантового компьютера?" : "Полный переход на PQC (ML-KEM/ML-DSA)"

8. Заключение: Бесконечная битва щита и меча

История криптографии — это история бесконечной борьбы между изобретением новых методов шифрования (щит) и новых методов взлома (меч).

Шифр Цезаря пал от частотного анализа, а непобедимая Энигма пала перед гениальным умом Тьюринга и силой машин. И теперь даже мощные криптосистемы, такие как RSA и ECC, которые поддерживают основу современного интернет-общества, находятся под угрозой нового “меча” — квантового компьютера.

Однако человечество уже смотрит в будущее и готовит новый “щит” — постквантовую криптографию (PQC). Сегодня обеспечение перехода от существующей криптографии с открытым ключом к PQC (обеспечение криптографической гибкости - Crypto Agility) является насущной задачей для IT-инфраструктуры во всем мире.

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

【Математическое объяснение】Как работает алгоритм RSA, объяснено для старшеклассников

Fri, 11 Sep 2026 13:00:00 +0900

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

Однако при слове “криптография” (шифрование) вы можете представить себе сложные шифровальные машины из шпионских фильмов или сверхсложную математику, понятную лишь избранным гениям. Безусловно, современная теория криптографии основана на продвинутой математике, но фундаментальный механизм алгоритма RSA вполне можно понять, обладая знаниями математики на уровне старшей школы (свойства целых чисел, простые числа, сравнения по модулю и т.д.).

В этой статье, взяв за отправную точку знания школьной математики, мы шаг за шагом подробно объясним, на каких математических принципах работает алгоритм RSA и почему его так сложно взломать. Мы будем использовать конкретные примеры и объяснять все так тщательно, чтобы даже те, кто немного не в ладах с математикой, смогли во всем разобраться.

1. Симметричное и асимметричное шифрование (с открытым ключом)

Прежде чем переходить к математическим механизмам алгоритма RSA, давайте проясним базовые концепции криптографии. Методы шифрования в целом делятся на два типа: “шифрование с симметричным ключом” и “шифрование с открытым ключом” (асимметричное).

1.1 Ограничения симметричного шифрования

Большинство шифров, используемых с древних времен, называются “системами симметричного шифрования”. Это метод, при котором для “шифрования” (превращения сообщения в секретный шифр) и “расшифрования” (возвращения зашифрованного текста в исходное сообщение) используется один и тот же ключ.

Например, предположим, что Алиса отправляет Бобу секретное письмо. Алиса кладет письмо в шкатулку и запирает ее на навесной замок (общий ключ). Чтобы Боб мог открыть эту шкатулку, у него должен быть точно такой же ключ, какой использовала Алиса.

У этого метода есть серьезная проблема: “проблема распределения ключей”. Если находящиеся далеко друг от друга Алиса и Боб связываются впервые, как им безопасно обменяться ключами, чтобы их никто не перехватил? Если ключ украдет третье лицо во время пересылки, все последующие зашифрованные сообщения станут достоянием гласности.

1.2 Революционное изобретение: “Шифрование с открытым ключом”

Для решения этой проблемы с распределением ключей была изобретена “система шифрования с открытым ключом”. Алгоритм RSA относится к этому типу.

В системе с открытым ключом используются два разных ключа: “ключ для шифрования (открытый ключ)” и “ключ для расшифрования (закрытый ключ)”.

Получатель, Боб, создает пару ключей: “открытый ключ” и “закрытый ключ”.
Боб публикует свой “открытый ключ” на весь мир (неважно, кто его получит).
Отправительница, Алиса, использует “открытый ключ” Боба, чтобы зашифровать сообщение и отправить его.
Зашифрованное сообщение можно расшифровать только с помощью “закрытого ключа”, который есть только у Боба.

Если снова привести аналогию с навесным замком, то Боб создает множество “открытых навесных замков (открытых ключей)” и разбрасывает их по всему миру. Алиса кладет свое сообщение для Боба в шкатулку, берет один из замков Боба и защелкивает его. Как только замок закрыт, его можно открыть только с помощью “мастер-ключа (закрытого ключа)”, который есть у Боба. Даже если кто-то украдет шкатулку по дороге, он не сможет ее открыть без мастер-ключа.

graph TD A["Алиса (отправитель)"] --> B["Открытый текст (сообщение)"] B --> C["Процесс шифрования"] D["Открытый ключ Боба (доступен всем)"] --> C C --> E["Отправка через интернет: Зашифрованный текст"] E --> F["Процесс расшифрования"] G["Закрытый ключ Боба (только у Боба)"] --> F F --> H["Восстановленный открытый текст (сообщение)"] H --> I["Боб (получатель)"]

Чтобы реализовать эту революционную систему, потребовалась своего рода “односторонняя функция (математическая головоломка с односторонним движением)”, которая позволяет “легко зашифровать с помощью открытого ключа, но абсолютно невозможно расшифровать без закрытого”. И в качестве деталей для этой головоломки были выбраны хорошо знакомые нам “простые числа”.

2. Математические основы RSA 1: Простые числа и факторизация

Безопасность алгоритма RSA основана на математическом факте: “факторизация (разложение на простые множители) огромных чисел — чрезвычайно сложная задача”.

2.1 Что такое простые числа?

Простое число — это “натуральное число больше 1, которое делится без остатка только на 1 и на само себя”. Пример: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Простые числа — это словно “атомы” всех целых чисел. Любое натуральное число можно разложить в виде произведения простых чисел. Это называется факторизацией (разложением на простые множители). Например, $60 = 2^2 \times 3 \times 5$. Тот факт, что любое число можно разложить на простые множители единственным образом (если не учитывать порядок), известен как “основная теорема арифметики”.

2.2 Сложность факторизации (Односторонняя функция)

Здесь важна асимметрия: “умножать легко, а раскладывать на множители — сложно”.

Например, попробуйте вычислить в уме произведение следующих двух простых чисел: $11 \times 13 = ?$ Это просто. Ответ $143$.

А как насчет следующего числа? Разложите на простые множители $323$. Ну как? Это должно занять некоторое время. (Ответ $17 \times 19$).

Если числа небольшие, человек еще может как-то справиться, но по мере увеличения чисел вычисления становятся взрывообразно сложными даже для компьютеров. В распространенном сегодня алгоритме RSA используется число $N = p \times q$, полученное путем перемножения двух невероятно огромных простых чисел $p$ и $q$ размером 2048 бит (около 600 цифр в десятичной системе).

Когда даны два огромных простых числа $p$ и $q$, вычисление $N$ занимает у компьютера долю секунды (меньше миллисекунды). Однако, если дано только $N$, поиск исходных $p$ и $q$ займет столько времени, что даже самые быстрые суперкомпьютеры современности не смогут решить эту задачу и за триллионы лет.

Эта “вычислительная асимметрия (в одну сторону легко, в обратную — сложно)” является фундаментом для создания связи между открытым и закрытым ключами.

3. Математические основы RSA 2: Сравнения (Арифметика остатков / модульная арифметика)

Вычисления в алгоритме RSA выполняются не в виде привычных нам сложений и умножений, где числа могут бесконечно расти, а в мире “остатков” от деления на определенное число. Это называется сравнением по модулю (модульной арифметикой).

3.1 Математика часов

Модульную арифметику часто сравнивают с “математикой часов”. Предположим, сейчас 10 часов. Который час будет через 5 часов? $10 + 5 = 15$ часов, но на обычных 12-часовых часах мы ответим “3 часа”. Это потому, что остаток от деления 15 на 12 равен 3.

В математике это записывается следующим образом:

$$ 15 \equiv 3 \pmod{12} $$

Это читается как “15 сравнимо с 3 по модулю 12 (остатки от деления на 12 равны)”.

3.2 Основные свойства сравнений

Сравнения обладают очень удобными свойствами, похожими на свойства обычных уравнений ($=$). Пусть модуль (делитель) равен $N$. Если $a \equiv b \pmod N$ и $c \equiv d \pmod N$, то выполняется следующее:

Сложение: $a + c \equiv b + d \pmod N$
Вычитание: $a - c \equiv b - d \pmod N$
Умножение: $a \times c \equiv b \times d \pmod N$
Возведение в степень: $a^k \equiv b^k \pmod N$ (где $k$ — натуральное число)

Особенно важным является свойство “возведения в степень”. Оно означает, что “остаток от степени равен степени от остатка”. Например, мы хотим найти остаток от деления $7^{100}$ на $5$. Честно умножать $7$ само на себя 100 раз, а затем делить на $5$ было бы очень сложно. Но используя свойства сравнений, поскольку $7 \equiv 2 \pmod 5$, мы получаем $7^{100} \equiv 2^{100} \pmod 5$, что позволяет кардинально упростить вычисления. В мире криптографии мы работаем с возведением в степень очень больших чисел, поэтому это свойство просто необходимо.

4. Математические основы RSA 3: Функция Эйлера и теорема Эйлера

Здесь начинается магическая математика, составляющая ядро RSA. Появляется “теорема Эйлера”, которая является обобщением “малой теоремы Ферма”.

4.1 Функция Эйлера (тотиент) $\phi(N)$

Функция Эйлера (функция $\phi$) для некоторого натурального числа $N$ — это функция, которая возвращает “количество натуральных чисел от 1 до $N$, которые взаимно просты с $N$ (наибольший общий делитель равен 1)”.

Давайте рассмотрим несколько примеров.

$\phi(5)$: Среди 1, 2, 3, 4, 5 взаимно простыми с 5 являются 1, 2, 3, 4 — всего 4 числа. Следовательно, $\phi(5) = 4$.
$\phi(6)$: Среди 1, 2, 3, 4, 5, 6 взаимно простыми с 6 являются 1, 5 — всего 2 числа. Следовательно, $\phi(6) = 2$.

【Особое свойство для простых чисел】 Если $p$ — простое число, все числа от 1 до $p-1$ взаимно просты с $p$. Следовательно,

$$ \phi(p) = p - 1 $$

【Особое свойство для произведения простых чисел】 Для двух различных простых чисел $p$ и $q$, если $N = p \times q$, то $\phi(N)$ можно легко вычислить следующим образом:

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Это свойство служит “потайной дверью” (лазейкой) в алгоритме RSA. Тот, кто знает $p$ и $q$ (создатель ключа), может вычислить $\phi(N)$ за мгновение, но третье лицо, знающее только $N$, не сможет вычислить $\phi(N)$ без разложения $N$ на простые множители.

4.2 Теорема Эйлера

Леонард Эйлер, используя функцию $\phi(N)$, доказал следующую красивую теорему.

Теорема Эйлера: Если целое число $a$ и $N$ взаимно просты, то выполняется следующее сравнение:

$$ a^{\phi(N)} \equiv 1 \pmod N $$

Это удивительное свойство: “если умножить некоторое число $a$ само на себя $\phi(N)$ раз и разделить на $N$, остаток всегда будет равен $1$”. (Если $N$ — простое число $p$, это принимает вид $a^{p-1} \equiv 1 \pmod p$ и называется малой теоремой Ферма).

Давайте преобразуем эту теорему Эйлера. Умножим обе части на $a$ еще раз.

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

Более того, для любого целого числа $k$, $a^{k \cdot \phi(N)}$ также будет равно $1^k = 1$, поэтому выполняется следующее равенство:

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

Именно эта формула является фундаментальным принципом, на котором строится магия RSA: “после шифрования и расшифрования мы возвращаемся к исходному значению”.

5. Алгоритм RSA: Шаги генерации ключей, шифрования и расшифрования

Теперь, когда у нас есть базовые знания, давайте посмотрим на конкретные шаги алгоритма RSA. Алгоритм RSA можно разделить на три основные фазы: “1. Генерация ключей”, “2. Шифрование” и “3. Расшифрование”.

flowchart TD A1["1. Выбрать простые числа p, q"] --> A2["Вычислить N = p × q"] A1 --> A3["Вычислить φ(N) = (p-1)(q-1)"] A3 --> A4["Выбрать e, взаимно простое с φ(N)"] A3 --> A5["Вычислить d такое, что e × d ≡ 1 (mod φ(N))"] A2 --> A6["Открытый ключ (N, e)"] A4 --> A6 A5 --> A7["Закрытый ключ d"] B1["2. Открытый текст (сообщение) M"] --> B2["Вычислить C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Отправить зашифрованный текст C"] B3 --> C1["3. Полученный зашифрованный текст C"] C1 --> C2["Вычислить M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Получить исходный открытый текст M"]

5.1 Генерация ключей (Key Generation)

Получатель, Боб, генерирует для себя “открытый ключ” и “закрытый ключ”.

Выбор простых чисел: Случайным образом выбираются два больших простых числа $p$ и $q$.
Вычисление модуля $N$: Вычисляется $N = p \times q$. Это $N$ становится публичным.
Вычисление $\phi(N)$: Вычисляется функция Эйлера $\phi(N) = (p - 1)(q - 1)$. Это секретное число Боба.
Выбор открытого ключа $e$: Выбирается целое число $e$ такое, что $1 < e < \phi(N)$ и $e$ взаимно просто с $\phi(N)$.
Вычисление закрытого ключа $d$: Находится целое число $d$, удовлетворяющее следующему условию: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Иными словами, “$d$ — это такое число, при котором остаток от деления $e \times d$ на $\phi(N)$ равен $1$”.

На этом подготовка ключей завершена.

Открытый ключ: Пара $(N, e)$. Публикуется для всего мира.
Закрытый ключ: $d$. Никогда никому не передается.

5.2 Шифрование (Encryption)

Допустим, Алиса хочет отправить Бобу секретное сообщение $M$. ($M$ — это числовое представление текста, причем $0 \le M < N$). Алиса использует открытый ключ Боба $(N, e)$ и выполняет следующие вычисления:

$$ C \equiv M^e \pmod N $$

Она вычисляет “остаток $C$ от деления сообщения $M$ в степени $e$ на $N$”. Это $C$ и есть зашифрованный текст.

5.3 Расшифрование (Decryption)

Боб получает зашифрованный текст $C$. Боб использует закрытый ключ $d$ и выполняет следующие вычисления:

$$ M \equiv C^d \pmod N $$

Если вычислить “остаток от деления зашифрованного текста $C$ в степени $d$ на $N$”, то удивительным образом восстанавливается исходное сообщение $M$!

6. Почему расшифрование возвращает исходное сообщение? (Математическое доказательство)

Вы можете задаться вопросом: “Как так получается, что простое возведение $C$ в степень $d$ возвращает нас к исходному $M$?”. Вот тут-то и проявляет свою силу ранее упомянутая “теорема Эйлера”.

Давайте подставим формулу шифрования $C = M^e$ в формулу расшифрования $C^d \pmod N$.

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Здесь вспомните шаг 5 генерации ключей. Боб при создании $d$ выбрал его так, чтобы выполнялось условие $e \times d \equiv 1 \pmod{\phi(N)}$. Это означает, что “$ed$ — это число, кратное $\phi(N)$, плюс $1$”. Используя целое число $k$, это можно записать следующим образом:

$$ ed = k \cdot \phi(N) + 1 $$

Подставим это в показатель степени и разложим с помощью правил возведения в степень:

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

Если предположить, что сообщение $M$ и $N$ взаимно просты, то согласно теореме Эйлера получаем $M^{\phi(N)} \equiv 1 \pmod N$.

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

Следовательно, блестяще выполняется следующая формула:

$$ C^d \equiv M \pmod N $$

Алиса не знает $d$, перехватчик тоже не знает $d$, поэтому получить $M$ из $C$ может только Боб, владеющий ключом $d$.

7. Конкретный пример: давайте испытаем RSA вручную, используя небольшие простые числа

Давайте попробуем выполнить зашифрованную связь от Алисы к Бобу на практике, используя небольшие числа (простые числа).

【Фаза генерации ключей Боба】

Выбираем два простых числа $p=11$, $q=13$.
Вычисляем $N = 11 \times 13 = 143$.
Вычисляем $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Выбираем открытый ключ $e$, взаимно простой с $\phi(N)=120$. Пусть $e=7$.
Находим закрытый ключ $d$. Ищем такое $d$, чтобы выполнялось $7 \times d \equiv 1 \pmod{120}$. В уравнении $7d = 120k + 1$, если $k=6$, получаем $721$, а $721 \div 7 = 103$. Следовательно, $d = 103$.

Открытый ключ: $(N=143, e=7)$
Закрытый ключ: $d=103$

【Фаза шифрования Алисы】 Предположим, мы хотим отправить сообщение $M = 9$. Формула: $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$. Если разделить это число на 143, получим $33447$ с остатком $48$. Зашифрованный текст получился $C = 48$.

【Фаза расшифрования Боба】 Боб получает зашифрованный текст $C = 48$ и использует закрытый ключ $d = 103$ для его расшифрования. Формула: $M \equiv 48^{103} \pmod{143}$ Если запустить на калькуляторе или в программе (48 ** 103) % 143, результат блестяще окажется равным “9”! Исходное сообщение успешно получено.

8. Как найти закрытый ключ $d$: Расширенный алгоритм Евклида

В примере с ручными вычислениями мы нашли $d=103$, подобрав $k$ интуитивно, но если числа состоят из сотен цифр, этот метод не сработает. В реальных программах используется алгоритм, называемый “расширенным алгоритмом Евклида”.

Решить $7d \equiv 1 \pmod{120}$ — это то же самое, что найти целые числа $d$ и $y$, удовлетворяющие уравнению $7d + 120y = 1$. Выполняя алгоритм Евклида в обратном порядке, это можно вычислить механически.

$120 \div 7 = 17$, остаток $1$
Если преобразовать это, получим $1 = 120 - 17 \times 7$
То есть, $-17 \times 7 \equiv 1 \pmod{120}$

В мире по модулю $120$, число $-17$ имеет то же значение, что и $120 - 17 = 103$. Следовательно, мы мгновенно находим $d = 103$. Этот метод позволяет выполнять вычисления очень быстро даже для огромных чисел.

9. Другое лицо RSA: Цифровая подпись

Замечательной особенностью алгоритма RSA является то, что, поменяв ролями открытый и закрытый ключи, его можно использовать как “цифровую подпись”.

При шифровании порядок был таким: “шифрование открытым ключом $\Rightarrow$ расшифрование закрытым ключом”, а в цифровой подписи выполняется процедура “шифрование закрытым ключом $\Rightarrow$ расшифрование открытым ключом”.

flowchart TD A1["1. Алиса создает подпись с помощью закрытого ключа"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Отправить сообщение M и подпись S"] A3 --> B1["2. Боб проверяет подпись с помощью открытого ключа"] B1 --> B2["Вычислить M' ≡ S^e (mod N)"] B2 --> B3["Проверить, совпадают ли M' и M"]

Алиса использует свой закрытый ключ $d$ для преобразования сообщения (это и есть подпись $S$) и отправляет его Бобу. Боб использует открытый ключ Алисы $e$ для выполнения проверочных вычислений. Если результат вычислений совпадает с исходным сообщением, это одновременно доказывает, что “эти данные могли быть созданы только с помощью закрытого ключа Алисы” и что “сообщение не было изменено в пути”.

10. RSA на практике в коде

Возведение в степень, которое сложно сделать вручную, очень легко реализовать с помощью Python. Ниже представлен код на Python, позволяющий опробовать основную логику алгоритма RSA.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """Найти наибольший общий делитель"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Найти закрытый ключ d (используется встроенная функция Python 3.8 и выше)"""
 return pow(e, -1, phi)

# 1. Генерация ключей
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Открытый ключ: (N={N}, e={e}), Закрытый ключ: d={d}")

# 2. Шифрование
message = 9
ciphertext = pow(message, e, N)
print(f"Зашифрованный текст: {ciphertext}")

# 3. Расшифрование
decrypted_message = pow(ciphertext, d, N)
print(f"Расшифрованное сообщение: {decrypted_message}")

Функция pow(base, exp, mod) в Python внутри использует быстрый алгоритм, называемый “алгоритмом возведения в степень справа налево” (быстрое возведение в степень по модулю), поэтому вычисления для чисел из сотен цифр завершаются мгновенно.

11. Заключение и будущее криптографии

Основываясь на знаниях школьной математики, мы разобрали механизмы работы алгоритма RSA.

Сложность факторизации: Легко вычислить $p \times q = N$, но очень сложно найти $p, q$ по заданному $N$.
Сравнения и теорема Эйлера: Благодаря закону $a^{\phi(N)} \equiv 1 \pmod N$ создается волшебная потайная дверь, позволяющая “вернуться к исходному значению при возведении в определенную степень”.
Открытый и закрытый ключи: Зашифровать может кто угодно, но расшифровать способен только законный получатель.

Используемое в настоящее время в алгоритме RSA число $N$ состоит из более чем 600 цифр, и даже если задействовать все суперкомпьютеры в мире, разложение его на множители займет больше времени, чем возраст Вселенной. Однако, когда “квантовые компьютеры”, исследования которых ведутся в последние годы, будут введены в практическое использование в будущем, с помощью “алгоритма Шора” эту задачу факторизации можно будет решить за мгновение. По этой причине во всем мире сейчас ускоренными темпами ведется разработка “постквантовой криптографии”, которая не может быть взломана даже квантовыми компьютерами.

Продвинутая математика, которая часто считается “бесполезной”, на самом деле фундаментально защищает нашу повседневную жизнь. Алгоритм RSA — это прекрасный учебный материал, который демонстрирует глубину и красоту математики. Мы надеемся, что благодаря этой статье вы смогли хотя бы немного почувствовать, насколько интересными могут быть криптография и математика.

Что такое полностью гомоморфное шифрование (FHE)? Объяснение основы безопасности следующего поколения

Fri, 11 Sep 2026 11:00:00 +0900

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

Традиционные технологии шифрования (такие как AES и RSA) отлично справляются с защитой данных, хранящихся в хранилище (Data at Rest) и передаваемых по сети (Data in Transit). Однако при выполнении обработки (вычислений) на стороне сервера, например, поиска или машинного обучения над данными (Data in Use), необходимо сначала расшифровать их и вернуть в виде открытого текста. Если сервер будет взломан в момент расшифровки, или если злонамеренный внутренний администратор заглянет в данные, это приведет к прямой утечке информации.

Технология мечты, которая преодолевает эту фундаментальную слабость «расшифровки во время обработки», — это полностью гомоморфное шифрование (Fully Homomorphic Encryption: FHE). Использование FHE позволяет выполнять вычислительную обработку данных, оставляя их зашифрованными без какой-либо расшифровки, и возвращать клиенту только зашифрованный результат.

В этой статье мы глубоко и детально рассмотрим FHE, основу безопасности следующего поколения, начиная от концепции и истории, новаторского прорыва Крейга Джентри, математических основ (таких как Ring-LWE), до самой большой проблемы — «шума» — и ее решения (bootstrapping, начальная загрузка/загрузка), а также новейших библиотек реализаций.

1. Что такое гомоморфное шифрование? Основные концепции

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

Выражаясь простой математической формулой, пусть $E(\cdot)$ будет функцией шифрования, а $D(\cdot)$ — функцией дешифрования для открытых текстов $m_1$ и $m_2$. Если операция над открытым текстом (например, сложение или умножение) обозначается как $\circ$, а операция над шифротекстом — как $\diamond$, то выполняется следующее соотношение:

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

Другими словами, расшифровка результата применения какой-либо операции $\diamond$ к шифротекстам $E(m_1)$ и $E(m_2)$ совпадает с результатом применения операции $\circ$ к исходным открытым текстам.

Поток данных в облачных вычислениях

Архитектура облачной обработки с использованием FHE полностью отличается от традиционной. На следующем рисунке показан поток безопасной обработки данных с использованием FHE.

Сервер получает зашифрованные данные $E(x)$, но, поскольку у него нет закрытого ключа, он абсолютно не может знать содержимое данных. Однако, используя свойства FHE, можно применить функцию $f$ (например, модель машинного обучения) к шифротексту и сгенерировать $E(f(x))$. Клиент получает это и расшифровывает с помощью своего собственного закрытого ключа, получая таким образом желаемый результат $y = f(x)$.

2. История эволюции гомоморфного шифрования: PHE, SHE, FHE

Гомоморфное шифрование не сразу приняло свою нынешнюю «полную» форму. Оно широко подразделяется на три этапа в зависимости от типов и количества операций, которые могут быть выполнены.

Partially Homomorphic Encryption (PHE: Частично гомоморфное шифрование)

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

Шифрование RSA (гомоморфизм по умножению) Шифрование RSA непреднамеренно обладало гомоморфизмом по умножению. Пусть открытые тексты равны $m_1, m_2$, а открытый ключ — $(e, N)$: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ Если перемножить их, то получится: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ Таким образом, умножение шифротекстов соответствует умножению открытых текстов.
Шифрование Пэйе (гомоморфизм по сложению) Шифрование Пэйе (Paillier), изобретенное в 1999 году, обладает гомоморфизмом по сложению. Оно применяется на практике, например, в электронном голосовании (подсчет зашифрованных голосов и расшифровка только конечного результата).

Somewhat Homomorphic Encryption (SHE: Ограниченно гомоморфное шифрование)

Это схема, которая может выполнять обе операции, сложение и умножение, но имеет ограничение на количество выполняемых операций (глубину схемы). Из-за накопления «шума», о котором будет рассказано позже, дешифрование становится невозможным после определенного количества умножений. К этой категории относится шифр BGN (Boneh-Goh-Nissim) 2005 года, но у него были ограничения для выполнения практических сложных вычислений (таких как глубокое обучение).

Fully Homomorphic Encryption (FHE: Полностью гомоморфное шифрование)

Это схема шифрования, которая позволяет выполнять как сложение, так и умножение неограниченное количество раз. Подобно полноте по Тьюрингу в теории информации, если сложение (соответствует XOR) и умножение (соответствует AND) можно комбинировать бесконечно, это означает, что в принципе любая вычислимая функция или алгоритм могут быть выполнены в зашифрованном виде.

FHE долгое время называли «Святым Граалем криптографии» и считали невозможным. Однако в 2009 году Крейг Джентри, в то время аспирант Стэнфордского университета, предложил первую схему FHE с использованием идеальных решеток (Ideal Lattices), что потрясло мир.

3. Математические основы FHE: Задача LWE и Ring-LWE

Многие из современных господствующих схем FHE основаны на задаче LWE (Обучение с ошибками, Learning With Errors), сложной математической проблеме в «криптографии на решетках (Lattice-based Cryptography)», которая также известна как постквантовая криптография.

Интуитивное понимание задачи LWE

Решение системы линейных уравнений является простой задачей, если использовать такие методы, как метод исключения Гаусса.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

Но что произойдет, если к результатам этих уравнений добавить крошечную «случайную ошибку (шум)» $e$?

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

Добавление только этой ошибки $e$ превращает задачу нахождения секретного вектора переменных $\vec{s}$ в NP-трудную задачу, которую трудно взломать даже с помощью современных суперкомпьютеров или квантовых компьютеров. Это и есть задача LWE.

Задача Ring-LWE (RLWE)

Стандартная задача LWE включает в себя матричные операции, поэтому она имела проблему огромных размеров ключей (которые могли достигать гигабайт) и низкой вычислительной эффективности. Для решения этой проблемы была введена задача Ring-LWE (RLWE), которая использует операции над кольцами многочленов.

В RLWE элементы принадлежат кольцу многочленов $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ (где $N$ — степень двойки, а $q$ — простое число, выступающее в качестве модуля). Если закрытый ключ является многочленом $s(x)$, а случайный многочлен — $a(x)$, и небольшой многочлен шума — $e(x)$, то открытый ключ будет представлять собой следующую пару:

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

При шифровании открытый текст $m(x)$ кодируется с использованием свойств этого многочлена для генерации шифротекста.

4. Самое большое препятствие «Шум» и Bootstrapping Джентри

Самая важная концепция в понимании FHE — это «управление шумом».

Шифры на основе LWE/RLWE преднамеренно включают небольшой «шум (ошибку)» для обеспечения безопасности. Процесс дешифрования шифротекста $c$ открытого текста $m$, грубо говоря, выражается следующей формулой:

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

При дешифровании этот noise (шум) удаляется посредством округления, в результате чего получается правильный открытый текст $m$. Однако при выполнении гомоморфных операций (особенно умножения) между шифротекстами этот шум резко возрастает.

Гомоморфное сложение: Шум увеличивается аддитивно ($e_1 + e_2$). Это относительно постепенное увеличение.
Математическое выражение гомоморфизма посредством гомоморфного сложения: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
Гомоморфное умножение: Шум возрастает мультипликативно взрывным образом (поскольку он включает $e_1 \times e_2$ и т. д.). После всего нескольких умножений шум превышает порог $q/2$, в результате чего невозможно выполнить правильное округление, и дешифрование завершается неудачей.
Математическое выражение гомоморфизма посредством гомоморфного умножения: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

Именно поэтому FHE долгое время не удавалось реализовать, и все ограничивалось SHE (с ограничением количества операций).

Магия Bootstrapping (перезагрузки)

Гениальный вклад Крейга Джентри заключается в изобретении метода снижения шума, называемого «bootstrapping». Это был сдвиг парадигмы в криптографии.

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

Допустим, есть шифротекст с высоким уровнем шума $C_{noisy}$.
Клиент заранее передает серверу «зашифрованный с помощью открытого ключа» закрытый ключ $sk$, $E_{pk}(sk)$ (называемый ключом bootstrapping).
Сервер гомоморфно выполняет схему дешифрования (Decryption Circuit) над $C_{noisy}$.
В частности, он выполняет «дешифрование в зашифрованном пространстве» для $E_{pk}(C_{noisy})$ с использованием $E_{pk}(sk)$.
Поскольку сама эта схема дешифрования также является гомоморфной операцией, она генерирует новый шум, но шум результирующего нового шифротекста $C_{fresh}$ сбрасывается до определенного «фиксированного уровня».

graph LR A["Шифротекст с высоким шумом C_noisy"] --> B["Гомоморфная схема дешифрования (Eval_Dec)"] C["Зашифрованный закрытый ключ E(sk)"] --> B B --> D["Шифротекст с низким шумом C_fresh"] style B fill:#ffeeba,stroke:#ffc107

Периодически выполняя этот bootstrapping в процессе вычислений, теоретически стало возможным вычислять схемы бесконечной глубины (достижение FHE). Однако в первоначальном методе Джентри эта операция bootstrapping занимала от нескольких десятков минут до нескольких часов на один раз, что было катастрофически затратно в вычислительном плане.

5. Поколения FHE и эволюция основных схем

В целях практического применения FHE криптографы со всего мира соревновались в совершенствовании алгоритмов. В настоящее время FHE классифицируется в основном на четыре поколения/семейства.

Второе поколение: Точные операции над целыми числами (BGV, BFV)

Схемы BGV (Brakerski-Gentry-Vaikuntanathan) и BFV (Brakerski/Fan-Vercauteren) появились в 2011–2012 годах. Они основаны на RLWE и подходят для модульных арифметических операций над целыми числами (точные вычисления). Они поддерживают методы пакетирования (Batching), такие как SIMD (Single Instruction, Multiple Data), и характеризуются способностью упаковывать тысячи слотов данных в один огромный полиномиальный шифротекст и вычислять их параллельно за один раз.

Третье поколение: Ускорение Bootstrapping (GSW, FHEW, TFHE)

Схема GSW (Gentry-Sahai-Waters) 2013 года упростила структуру FHE. Ее развитием является TFHE (Fast Fully Homomorphic Encryption over the Torus), одно из современных основных направлений. Особенностью TFHE является чрезвычайно быстрый bootstrapping (в миллисекундах). Он эффективен при выполнении операций на уровне логических вентилей (логические схемы, такие как AND, XOR) и имеет относительно небольшой размер шифротекста, что делает его подходящим для быстрой оценки любых логических схем.

Четвертое поколение: Специализация на приближенных вычислениях и машинном обучении (CKKS)

Схема CKKS (Cheon-Kim-Kim-Song), предложенная Cheon и соавторами в 2017 году, может считаться окончательной технологией для защиты конфиденциальности в современном ИИ и машинном обучении. В то время как предыдущие FHE фокусировались на «точных целочисленных вычислениях», CKKS поддерживает «приближенные вычисления чисел с плавающей запятой» в зашифрованном виде. Он демонстрирует невероятную производительность в вычислениях над вещественными числами, где допускаются небольшие ошибки, таких как обучение и логический вывод нейронных сетей.

В следующей таблице обобщено, как выбрать схему в зависимости от цели.

Имя схемы	Подходящий тип данных	Рекомендуемые варианты использования	Особенности
BFV / BGV	Целые числа (Integer)	Точные статистические расчеты, агрегация финансовых данных, поиск в БД	Высокая пропускная способность за счет пакетирования SIMD
CKKS	Вещественные числа (Real/Complex)	Машинное обучение (DNN, логистическая регрессия), обработка сигналов	Ускорение за счет приближенных вычислений, масштабирование (rescaling)
TFHE	Булевы значения (Boolean)	Любые логические схемы, поиск по строкам, оценка нелинейных функций	Сверхбыстрый bootstrapping (на уровне миллисекунд)

6. Практика: Библиотеки FHE и концептуальный код

В настоящее время доступно множество библиотек с открытым исходным кодом, которые позволяют использовать FHE без глубоких знаний криптографии.

Microsoft SEAL (Simple Encrypted Arithmetic Library): Библиотека C++, поддерживающая BFV, BGV и CKKS. Один из отраслевых стандартов. Ее привязка для Python, TenSEAL, популярна среди инженеров ИИ.
Zama (Concrete): Фреймворк на базе TFHE. Может быть написан на Rust/Python, предоставляет функциональность (Concrete ML) для компиляции существующих моделей PyTorch для работы поверх FHE.
OpenFHE: Преемник PALISADE, комплексная библиотека C++, поддерживающая все основные схемы.

Пример программирования FHE на Python (TenSEAL)

Здесь показан концептуальный пример кода на Python, использующий схему CKKS для сложения и умножения векторов вещественных чисел в зашифрованном виде.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. Настройка контекста (включая генерацию ключей)
# Использование схемы CKKS и установка степени полинома 8192
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # Коэффициент масштабирования для вещественных чисел

# 2. Сторона клиента: Шифрование данных
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# Преобразование векторов открытого текста в шифротекст (Обычно выполняется на стороне клиента)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. Сторона сервера: Операции в зашифрованном виде (Защита Data in Use)
# Сервер не знает открытого текста, но может выполнять сложение и умножение
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. Сторона клиента: Дешифрование результатов
# Только клиент с закрытым ключом может видеть результат
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"Расшифрованный результат сложения: {res_add}")
# Пример вывода: [3.5000001, 5.5000001, 7.5000002] (Включает небольшие ошибки из-за приближенных вычислений)

print(f"Расшифрованный результат умножения: {res_mul}")
# Пример вывода: [3.0000002, 7.5000005, 14.0000003]

Как видно из приведенного выше кода, можно интуитивно описывать вычисления между шифротекстами путем перегрузки обычных операторов Python, например, enc_v1 + enc_v2. На стороне сервера векторные операции завершаются без знания содержимого векторов.

7. Проблемы FHE: Производительность и аппаратное ускорение

Хотя FHE обеспечивает теоретически идеальную безопасность, самой большой проблемой на пути к практическому применению являются «накладные расходы на производительность».

Вычислительные накладные расходы: По сравнению с вычислениями с открытым текстом вычисления с шифротекстом на CPU медленнее в тысячи и десятки тысяч раз. Умножение полиномов и bootstrapping требуют огромных вычислений БПФ (быстрого преобразования Фурье) и NTT (теоретико-числового преобразования).
Увеличение размера данных (Ciphertext Expansion): Несколько байтов открытого текста при шифровании могут превратиться в несколько мегабайтов. Это создает большую нагрузку на пропускную способность памяти и сети.

Подходы к аппаратному решению

Чтобы преодолеть эти накладные расходы, по всему миру разрабатываются аппаратные ускорители (соответствующие ASIC, FPGA, GPU), специально предназначенные для FHE.

Ускорение на GPU: Ведутся работы по распараллеливанию вычислений NTT и bootstrapping с использованием мощных графических процессоров, таких как от NVIDIA, и сообщается об ускорении в десятки раз по сравнению с программными реализациями (например, 100x.ai, TFHE-rs CUDA backend от Zama).
Проект DARPA DPRIVE: Агентство передовых исследований проектов обороны США (DARPA) продвигает проект разработки специализированного аппаратного обеспечения «DPRIVE (Data Protection in Virtual Environments)», чтобы повысить скорость вычислений FHE до уровня скорости обработки открытого текста (с накладными расходами в пределах 10-кратного увеличения), в котором участвуют Intel, Microsoft, Intellectual Ventures и другие.
Появление FPU (FHE Processing Unit): Стартапы, такие как Cornami и Optalysys, приступили к разработке специализированных чипов для FHE с использованием оптических вычислений и специальной кремниевой архитектуры.

Возможно, в ближайшем будущем наступит эпоха, когда «FPU» будут стандартно устанавливаться в серверах и облачной инфраструктуре, подобно NPU (Neural Processing Unit) в ИИ.

8. Ожидаемые варианты использования

Теперь, когда FHE приближается к практической скорости, ожидаются прорывные инновации в следующих областях.

Защита конфиденциальности в медицинском и геномном анализе: Обучая ИИ в облаке на медицинских картах пациентов или данных ДНК из нескольких больниц в зашифрованном с помощью FHE виде, можно разрабатывать высокоточные модели диагностики рака или новые лекарства без нарушения законов о конфиденциальности (HIPAA или GDPR).
Выявление мошенничества и борьба с отмыванием денег (AML) в финансовых учреждениях: Конкурирующие банки могут сверять данные друг друга в зашифрованном состоянии, не раскрывая информацию о счетах клиентов или историю транзакций, обеспечивая межбанковский анализ для выявления огромных сетей мошеннических переводов.
Безопасный API вывода ИИ (MaaS: Model as a Service): Пользователи шифруют свой голос, изображения лиц или промпты и отправляют их в сервисы ИИ (такие как LLM, например, ChatGPT). Провайдер ИИ генерирует ответ, не зная ввода пользователя, и возвращает его в виде шифротекста. Это полностью устраняет опасения, что «ИИ может изучить или украсть личную информацию».

9. Заключение: Будущее криптографии лежит в «Невидимых вычислениях»

Точно так же, как изобретение криптографии с открытым ключом (RSA) в 1970-х годах сделало возможной безопасную связь в Интернете (например, HTTPS), изобретение FHE Крейгом Джентри является одной из самых важных вех в истории криптографии.

Сегодня полностью гомоморфное шифрование (FHE) вышло из лабораторной теории, и Microsoft, IBM, Intel, Google и множество стартапов вступили в стадию жесткой конкуренции за его практическое применение. Проблемы с вычислительными затратами и размером данных по-прежнему существуют, но благодаря совершенствованию алгоритмов и эволюции аппаратных ускорителей производительность продолжает улучшаться темпами, превышающими закон Мура.

Через несколько лет «вычисление зашифрованных данных» больше не будет чем-то особенным, а станет стандартной передовой практикой защиты данных в облачных сервисах. FHE — это основа безопасности следующего поколения, которая реализует окончательную совместимость конфиденциальности и использования данных в обществе, управляемом данными.

Математические основы эллиптической криптографии (ECC) и её реализация на C++

Fri, 11 Sep 2026 10:00:00 +0900

Математические основы эллиптической криптографии (ECC) и её реализация на C++

В современной криптографии криптография на эллиптических кривых (Elliptic Curve Cryptography: ECC) играет исключительно важную роль. От наших повседневных интернет-коммуникаций (HTTPS/TLS) до безопасных анклавов смартфонов, аутентификации серверов через SSH, беспарольной аутентификации, такой как FIDO, и даже криптоактивов, таких как биткойн и Ethereum — не будет преувеличением сказать, что основа доверия в современном цифровом обществе держится на ECC.

В этой статье мы подробно и объемно разберем, как работает криптография на эллиптических кривых. Мы начнем с прекрасной, но сложной математической теории, лежащей в её основе (алгебраическая геометрия над конечными полями), перейдем к практическим методам реализации на C++, а также рассмотрим методы безопасного написания кода для предотвращения атак по сторонним каналам (тайминг-атак).

1. Почему именно криптография на эллиптических кривых? (Сравнение с RSA)

Долгое время синонимом криптографии с открытым ключом был алгоритм RSA. Безопасность RSA основана на «сложности факторизации огромных составных чисел». Однако по мере роста вычислительных мощностей компьютеров, для поддержания уровня безопасности возникла необходимость постоянно увеличивать длину ключа RSA (количество бит модуля). В настоящее время рекомендуется использовать длину ключа как минимум 2048 бит, а для большей безопасности — 3072 или 4096 бит.

С другой стороны, безопасность криптографии на эллиптических кривых (ECC) основана на совершенно иной математической сложности — «задаче дискретного логарифмирования на эллиптической кривой (ECDLP)». До сих пор не найдено эффективного алгоритма (например, субэкспоненциального алгоритма) для решения ECDLP, и даже самые эффективные известные методы атаки требуют экспоненциального времени.

Благодаря этому свойству, решающим преимуществом ECC является то, что она может обеспечить уровень безопасности, эквивалентный RSA, при значительно меньшей длине ключа.

Уровень безопасности (бит)	Длина ключа RSA (бит)	Длина ключа ECC (бит)	Соотношение длин ключей
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Как показывает таблица выше, для достижения уровня безопасности в 128 бит (стандартный уровень на сегодняшний день) алгоритму RSA требуется ключ в 3072 бита, в то время как ECC достаточно всего 256 бит. Это позволяет сократить объем вычислений, уменьшить использование памяти и сэкономить пропускную способность сети, что дает подавляющее преимущество, особенно в средах с ограниченными ресурсами, таких как устройства IoT и смарт-карты.

2. Математическая подготовка: Теория групп и конечные поля

Чтобы по-настоящему понять криптографию на эллиптических кривых, необходимо усвоить базовые концепции абстрактной алгебры (теории групп и теории полей). Здесь мы кратко резюмируем базовые знания, необходимые для построения ECC.

2.1. Группа (Group) и Абелева группа

Группа (Group) — это множество $G$ в паре с бинарной операцией (здесь мы будем использовать сложение $+$) на этом множестве, то есть пара $(G, +)$, которая удовлетворяет следующим четырем аксиомам:

Замкнутость (Closure): Для любых $a, b \in G$ выполняется $a + b \in G$.
Ассоциативность (Associativity): Для любых $a, b, c \in G$ выполняется $(a + b) + c = a + (b + c)$.
Существование нейтрального элемента (Identity element): Существует такой элемент $e \in G$, что для любого $a \in G$ выполняется $a + e = e + a = a$. В случае аддитивной группы этот нейтральный элемент обычно обозначается как $0$ или $\mathcal{O}$.
Существование обратного элемента (Inverse element): Для любого $a \in G$ существует элемент $b \in G$, такой что $a + b = b + a = e$. Этот элемент $b$ обозначается как $-a$.

Кроме того, если порядок выполнения операции не влияет на результат, то есть выполняется следующее условие, группа называется абелевой (коммутативной) группой.

Коммутативность (Commutativity): Для любых $a, b \in G$ выполняется $a + b = b + a$.

Множество точек на эллиптической кривой образует эту абелеву группу, если задать определенное правило сложения.

2.2. Конечное поле (Finite Field)

В криптографии используются не поля с непрерывным и бесконечным числом элементов, такие как действительные или комплексные числа, а конечные поля (Finite Fields) или поля Галуа (Galois Fields), количество элементов в которых конечно.

Самым базовым конечным полем является простое поле $\mathbb{F}_p$, использующее простое число $p$. Оно представляет собой множество целых чисел $\{0, 1, 2, \dots, p-1\}$ с определенными на нем четырьмя арифметическими операциями (сложение, вычитание, умножение, деление) по модулю $p$ (остаток от деления на $p$).

Сложение: $(a + b) \pmod p$
Вычитание: $(a - b) \pmod p$
Умножение: $(a \times b) \pmod p$
Деление: $a \times b^{-1} \pmod p$ (где $b^{-1}$ — мультипликативный обратный элемент к $b$ по модулю $p$)

Вычисление мультипликативного обратного элемента (Modular Multiplicative Inverse) имеет решающее значение при реализации криптографии. Для нахождения $b^{-1}$, удовлетворяющего условию $b \times b^{-1} \equiv 1 \pmod p$, в основном используются следующие два алгоритма:

Расширенный алгоритм Евклида (Extended Euclidean Algorithm): Он быстр, но в зависимости от реализации время обработки может зависеть от входных значений, что создает риск тайминг-атак.
Малая теорема Ферма (Fermat’s Little Theorem): Если $p$ — простое число и $b \neq 0$, то справедливо $b^{p-1} \equiv 1 \pmod p$. Разделив обе части на $b$, получим $b^{p-2} \equiv b^{-1} \pmod p$. То есть, возведя $b$ в степень $p-2$, можно найти обратный элемент. Поскольку операцию возведения в степень легко реализовать за постоянное время, в криптографии предпочитают именно этот метод.

3. Уравнение эллиптической кривой и геометрия

3.1. Нормальная форма Вейерштрасса

Эллиптическая кривая (Elliptic Curve) — это плоская кривая, обычно определяемая уравнением, известным как нормальная форма Вейерштрасса (Weierstrass normal form):

$$ y^2 = x^3 + ax + b $$

Здесь $a$ и $b$ — константы. Условием того, что кривая не имеет особых точек (самопересечений или точек возврата) — то есть является гладкой кривой — является то, что следующий дискриминант (Discriminant) $\Delta$ не равен нулю:

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

Поскольку кривые с особыми точек снижают криптографическую безопасность, коэффициенты $a$ и $b$ всегда выбираются так, чтобы удовлетворять этому условию.

3.2. Бесконечно удаленная точка (Point at Infinity)

Для того чтобы эллиптическая кривая математически образовывала полную группу, в дополнение к точкам на плоскости вводится виртуальная точка, называемая «бесконечно удаленной точкой (Point at Infinity)». Она обозначается как $\mathcal{O}$.

Бесконечно удаленная точка $\mathcal{O}$ определяется как точка, в которой пересекаются все вертикальные линии на бесконечности. В теории групп эта бесконечно удаленная точка $\mathcal{O}$ выступает в качестве нейтрального элемента при сложении (нуля).

То есть для любой точки $P$ на кривой справедливо следующее:

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

Кроме того, обратный элемент $-P$ для точки $P = (x, y)$ определяется как точка, симметричная относительно оси x: $(x, -y)$. Таким образом:

$$ P + (-P) = \mathcal{O} $$

4. Групповые операции на эллиптической кривой (сложение точек и удвоение)

Основой криптографии на эллиптических кривых является операция «сложения (Addition)» точек на кривой. Она отличается от обычного сложения целых чисел и определяется на основе геометрических операций.

4.1. Геометрическое сложение (Метод касательных и секущих)

Процедура нахождения новой точки $R$ ($R = P + Q$) путем сложения двух разных точек $P$ и $Q$ на кривой выглядит следующим образом:

Проведите прямую линию (секущую) через точки $P$ и $Q$.
Эта линия обязательно пересечет эллиптическую кривую в третьей точке (назовем её $-R$). (※Согласно теореме алгебраической геометрии)
Отразив точку пересечения $-R$ симметрично относительно оси x (инвертировав знак координаты y), мы получим искомую точку $R$.

graph TD Step1["Провести прямую через P(x1, y1) и Q(x2, y2)"] --> Step2["Найти третью точку пересечения с кривой -R"] Step2 --> Step3["Отразить -R относительно оси x, чтобы получить R(x3, y3)"] Step3 -.-> Result["Это и есть R = P + Q"]

4.2. Удвоение точки (Point Doubling)

Если прибавить точку $P$ к самой себе ($P + P = 2P$), провести прямую через две точки невозможно. В этом случае проводится касательная (Tangent) к кривой в точке $P$.

Проведите касательную к кривой в точке $P$.
Эта касательная пересечет кривую в еще одной точке $-R$.
Отразив точку пересечения симметрично относительно оси x, мы получим искомую точку $R = 2P$.

4.3. Алгебраические формулы для вычислений

Геометрические операции можно преобразовать в алгебраические формулы для вычисления на компьютере. Все операции выполняются над конечным полем $\mathbb{F}_p$ (по модулю $p$).

Пусть точка $P = (x_1, y_1)$, а точка $Q = (x_2, y_2)$. Также пусть результирующая точка $R = P + Q = (x_3, y_3)$.

Обозначим наклон прямой через $\lambda$ (лямбда).

[Случай 1: $P \neq Q$ (Сложение точек)] Наклон $\lambda$ — это скорость изменения между двумя точками.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

Используя этот $\lambda$, можно найти $x_3$ и $y_3$ следующим образом:

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[Случай 2: $P = Q$ (Удвоение точки)] Наклон $\lambda$ будет равен наклону касательной, который находится с помощью дифференцирования. (Неявно дифференцируем $y^2 = x^3 + ax + b$)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

Следовательно:

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

Формулы для $x_3, y_3$ имеют ту же форму, что и при сложении, но поскольку $x_2 = x_1$, они выглядят так:

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] Эти формулы включают деление (вычисление обратного элемента по модулю), такое как $(x_2 - x_1)^{-1}$ или $(2y_1)^{-1}$. Поскольку вычисление обратного элемента по модулю требует больших вычислительных затрат, на практике обычно используются проективные системы координат, такие как «координаты Якоби (Jacobian Coordinates)», которые позволяют отложить выполнение деления.

5. Скалярное умножение и задача дискретного логарифмирования на эллиптической кривой (ECDLP)

Операция, требующая наибольшего объема вычислений и являющаяся ядром безопасности в криптографии на эллиптических кривых, — это скалярное умножение (Scalar Multiplication).

5.1. Что такое скалярное умножение

Операция сложения точки $P$ с самой собой $k$ раз называется скалярным умножением и обозначается как $kP$.

$$ kP = \underbrace{P + P + \dots + P}_{k\text{ раз}} $$

Здесь $k$ — это очень большое целое число (например, 256-битное число).

5.2. Задача дискретного логарифмирования на эллиптической кривой (ECDLP)

Безопасность криптографии на эллиптических кривых зависит от сложности следующей задачи.

Задача дискретного логарифмирования на эллиптической кривой (Elliptic Curve Discrete Logarithm Problem: ECDLP) Даны известная точка $P$ (базовая точка) и результирующая точка $Q$. Найдите скаляр $k$, удовлетворяющий уравнению $Q = kP$.

Вычислить $Q$ из $k$ и $P$ (в прямом направлении) легко (выполняется за полиномиальное время) с использованием алгоритма, описанного ниже. Однако вычислить $k$ из $P$ и $Q$ в обратном направлении практически невозможно (односторонняя функция) без полного перебора, для чего не существует эффективных методов. В криптографических протоколах $k$ соответствует «закрытому ключу», а $Q$ — «открытому ключу».

5.3. Алгоритм Double-and-Add (Удвоение и сложение)

Если $k$ — огромное число (например, $2^{256}$), простое сложение точки $P$ $k$ раз не завершится даже за время жизни Вселенной. Поэтому для быстрого скалярного умножения используется алгоритм Double-and-Add (бинарный метод).

Это эллиптический эквивалент метода возведения в степень (метода повторного возведения в квадрат) для целых чисел. Скаляр $k$ представляется в двоичном виде, и обработка идет от старшего бита к младшему.

Инициализируем точку $R$, хранящую результат, значением $\mathcal{O}$.
Для каждого бита $k$ от самого старшего до самого младшего повторяем следующее:
- Удваиваем $R$ (Point Doubling: $R = 2R$)
- Если текущий бит равен 1, прибавляем $P$ к $R$ (Point Addition: $R = R + P$)

Благодаря этому алгоритму объем вычислений кардинально сокращается с $O(k)$ до $O(\log_2 k)$, и вычисление становится возможным за реальное время (в миллисекундах).

6. Обмен ключами Диффи-Хеллмана на эллиптических кривых (ECDH)

Здесь мы объясним, как работает протокол обмена ключами ECDH (Elliptic Curve Diffie-Hellman), который является наиболее типичным примером применения ECC. ECDH — это механизм, позволяющий Алисе и Бобу безопасно сгенерировать и использовать общий секретный ключ (сеансовый ключ) в канале связи, который может прослушиваться (это ядро рукопожатия TLS).

[Предварительные параметры (Параметры домена)] Обе стороны заранее договариваются о используемой эллиптической кривой $E$, простом числе $p$ и базовой точке $G$. (Например, NIST P-256 или secp256k1)

sequenceDiagram participant Alice as "Alice (Алиса)" participant Bob as "Bob (Боб)" Note over Alice,Bob: "Открытые параметры: кривая E, базовая точка G, простое число p" Alice->>Alice: "Генерация закрытого ключа d_A (случайное целое число)" Alice->>Alice: "Вычисление открытого ключа Q_A = d_A * G" Bob->>Bob: "Генерация закрытого ключа d_B (случайное целое число)" Bob->>Bob: "Вычисление открытого ключа Q_B = d_B * G" Alice->>Bob: "Отправка открытого ключа Q_A (открытый текст)" Bob->>Alice: "Отправка открытого ключа Q_B (открытый текст)" Alice->>Alice: "Вычисление общего секрета S = d_A * Q_B" Bob->>Bob: "Вычисление общего секрета S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "Результаты вычислений S у обоих полностью совпадают!"

Злоумышленник (Ева) может перехватить передаваемые по сети $G$, $Q_A$ и $Q_B$, но из-за сложности ECDLP он не сможет вычислить закрытый ключ Алисы $d_A$ из $Q_A = d_A \cdot G$. Кроме того, перемножение $Q_A$ и $Q_B$ не дает общий ключ $S$, поэтому злоумышленник не может вычислить $S$.

7. Ловушки при реализации: Атаки по сторонним каналам и защита от них

Даже теоретически совершенный криптографический алгоритм может иметь уязвимости, возникающие в процессе его реализации в виде программы. Это и есть «атака по сторонним каналам (Side-Channel Attack)».

7.1. Тайминг-атака (Timing Attack)

Давайте вспомним описанный ранее алгоритм Double-and-Add.

1
2
3
4
5
6
7
8


// Псевдокод уязвимого алгоритма Double-and-Add
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Выполняется всегда
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // Выполняется только если бит равен 1!
 }
}

Эта реализация имеет фатальный недостаток. Поскольку операция сложения точек (Point Addition) выполняется, когда бит равен 1, время вычислений немного увеличивается по сравнению с ситуацией, когда бит равен 0. Кроме того, меняется поведение предсказателя переходов процессора и кэш-памяти. Злоумышленник, статистически проанализировав эти крошечные различия во времени вычисления (или энергопотреблении) тысячи раз, может полностью восстановить последовательность битов закрытого ключа $k$ по одному биту. Это называется тайминг-атакой.

7.2. Реализация с постоянным временем (Constant-Time): Лестница Монтгомери (Montgomery Ladder)

Чтобы предотвратить тайминг-атаки, необходимо использовать алгоритмы, в которых последовательность выполняемых инструкций и время вычислений всегда остаются постоянными (Constant-Time) независимо от значения битов закрытого ключа.

Типичным примером такого алгоритма является Лестница Монтгомери (Montgomery Ladder).

graph TD Start["Инициализация: R0 = O, R1 = P"] --> LoopStart["Для каждого бита i (начиная со старшего)"] LoopStart --> Cond{"Каково значение k_i?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["К следующему биту"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Все биты обработаны"| End["Конец: R0 - это результат (kP)"]

Прелесть лестницы Монтгомери заключается в том, что независимо от того, равен бит 0 или 1, «всегда выполняется одно сложение точек и одно удвоение точки». Это полностью устраняет зависимость времени вычисления от данных.

Однако если существует само ветвление (if (k_i == 0)), остается риск того, что время выполнения будет варьироваться из-за оптимизаций компилятора или предсказания переходов ЦП. Поэтому в реальных Constant-Time реализациях устраняют условные переходы (операторы if) и используют условный обмен (Conditional Swap), основанный на побитовых операциях.

8. Реализация криптографии на эллиптических кривых на C++

Теперь переведем теорию в код на C++. Практические криптографические библиотеки (такие как OpenSSL или libsodium) используют сложные ассемблерные оптимизации и координаты Якоби, но здесь мы покажем структуру понятной Constant-Time реализации с использованием аффинных координат для лучшего понимания математики.

Предположим, что для работы с большими целыми числами используется boost::multiprecision::cpp_int.

8.1. Модульная арифметика и обратный элемент

Сначала определим вспомогательные функции для операций в конечном поле. Мы реализуем вычисление обратного элемента с использованием Малой теоремы Ферма.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// Пример простого числа p и параметров для secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Операция по модулю, возвращающая положительный остаток
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// Вычисление степени по модулю (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// Обратный элемент по модулю с использованием малой теоремы Ферма
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Предполагается, что m - простое число: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Представление точек и групповые операции (сложение, удвоение)

Определим структуру Point, где бесконечно удаленная точка управляется с помощью флага, и реализуем формулы сложения.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // Создание бесконечно удаленной точки
 Point() : x(0), y(0), isInfinity(true) {}

 // Создание обычной точки
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Сложение точек на эллиптической кривой (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = бесконечно удаленная точка
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Удвоение точки (Point Doubling) (Если P = Q)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Сложение точек (Point Addition) (Если P != Q)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Реализация условного обмена с постоянным временем (Constant-Time Conditional Swap)

При обмене содержимым переменных на основе битового значения секретного ключа, мы выполняем обмен, используя только побитовые операции (маскирование) без операторов if. Это обеспечивает неизменность пути выполнения.

[!TIP] На практике классы для работы с длинной арифметикой, динамически выделяющие память, такие как cpp_int, не подходят для операций с постоянным временем. Это связано с тем, что информация о тайминге утекает через выделение памяти и изменение размеров массивов. Практические библиотеки используют представления фиксированной длины (например, массив из 4 элементов uint64_t) и реализуют операции маскирования на битовом уровне. Ниже приведен концептуальный пример.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Концептуальный обмен с постоянным временем (предполагается целое число фиксированной длины)
// Если bit равен 1, то меняет P1 и P2 местами, если 0 - не меняет
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit равен 0 или 1. Если bit=1, маска состоит из всех единиц (0xFF..), если 0 - из всех нулей.
 // (Здесь для пояснения предполагается, что каждое слово класса BigInt фиксированной длины - это w)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // Координата y и флаг isInfinity обрабатываются аналогично
 }
 */

 // ※ Полный swap за постоянное время в boost::multiprecision затруднителен,
 // но здесь мы ограничиваемся симуляцией с использованием ветвления для понимания логики.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Скалярное умножение с использованием лестницы Монтгомери

Объединив ранее описанные pointAdd и cswap, реализуем безопасное скалярное умножение.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Скалярное умножение k * P (Метод лестницы Монтгомери)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Бесконечно удаленная точка
 Point R1 = P;

 // Получение длины k в битах (256 бит для secp256k1)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Получение значения i-го бита (0 или 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Если bit == 1, меняем местами R0 и R1
 cswap(R0, R1, bit);

 // Всегда выполняются одни и те же операции (Сложение точек и Удвоение точки)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Если bit == 1, меняем местами снова, чтобы восстановить состояние
 cswap(R0, R1, bit);
 }

 return R0;
}

Благодаря этой логике реализации, независимо от того, равен ли каждый бит скаляра $k$ 0 или 1, операции, выполняемые в каждой итерации цикла (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap), имеют абсолютно идентичный поток выполнения. Это обеспечивает надежную защиту от утечек секретной информации через различия во времени или шаблоны доступа к кэшу.

9. Заключение

Криптография на эллиптических кривых (ECC) на первый взгляд может показаться загадкой: «Каким образом геометрическая операция проведения прямой линии и отражения точки пересечения становится криптографией?» Однако, отобразив это в дискретный мир конечных полей, можно построить превосходную одностороннюю функцию (задачу дискретного логарифмирования), что является плодом чудесного слияния математики и криптографии.

В этой статье мы объяснили следующие важные моменты:

Преимущество перед RSA: Обеспечивает высокий уровень безопасности при очень малой длине ключа, что идеально подходит для современной эры мобильных устройств и IoT.
Основы теории групп и конечных полей: Математическая структура, являющаяся фундаментом ECC.
Формулы сложения и удвоения: Метод реализации алгебраических групповых операций с использованием уравнения Вейерштрасса.
Угроза атак по сторонним каналам: То, что условные переходы, зависящие от битов секретного ключа, создают фатальные уязвимости.
Реализация с постоянным временем (Constant-Time): Техника кодирования на C++ для унификации поведения на аппаратном уровне и предотвращения атак с использованием Лестницы Монтгомери (Montgomery Ladder) и Условного обмена (Conditional Swap).

Создание собственной криптографической библиотеки для работы в продакшен-среде настоятельно не рекомендуется («Don’t roll your own crypto») из-за чрезвычайно высоких рисков безопасности. Тем не менее, глубокое понимание алгоритмов и математической основы, стоящей за ними, безусловно, станет мощным оружием для инженеров, проектирующих и эксплуатирующих более безопасные и производительные системы.

В следующей статье мы планируем глубже погрузиться в механизмы алгоритма цифровой подписи на эллиптических кривых (ECDSA - Elliptic Curve Digital Signature Algorithm) и подписей Шнорра (Schnorr), которые используются в Биткойне.

Существуют ли алгоритмы, превосходящие GNFS (общий метод решета числового поля)?

Fri, 11 Sep 2026 09:00:00 +0900

1. Введение: Факторизация целых чисел и основа современной криптографии

Безопасность интернет-коммуникаций в современном обществе во многом зависит от безопасности криптографии с открытым ключом, в частности алгоритма RSA. А безопасность RSA основана на математическом предположении о “сложности факторизации огромных составных чисел”. Если будет найден чрезвычайно эффективный алгоритм факторизации целых чисел, глобальная коммуникационная инфраструктура будет разрушена до основания.

В настоящее время общий метод решета числового поля (GNFS: General Number Field Sieve) является самым быстрым и мощным алгоритмом факторизации огромных целых чисел на классических компьютерах. GNFS появился как расширение специального метода решета числового поля (SNFS), предложенного в конце 1980-х годов, и до сих пор удерживает рекорды по факторизации таких огромных составных чисел, как RSA-768 и RSA-250.

Однако криптографы и математики постоянно задаются следующими вопросами: “Существует ли классический алгоритм, превосходящий GNFS?”, “Где лежат границы возможностей классических компьютеров?” и “Как квантовые компьютеры смогут преодолеть этот барьер?”.

В этой статье мы подробно разберем глубокую математическую структуру, лежащую в основе GNFS, и проведем детальный технический анализ выбора полиномов, процесса просеивания и этапа линейной алгебры с использованием метода Блока-Видемана. Кроме того, мы рассмотрим методы расширения GNFS, такие как улучшения Копперсмита, и сравним фундаментальные различия между классическими алгоритмами субэкспоненциального времени (Sub-exponential time) и квантовыми алгоритмами полиномиального времени с математической точки зрения.

2. Асимптотическая сложность и L-нотация (L-notation)

При оценке сложности алгоритмов факторизации целых чисел для выражения субэкспоненциального времени относительно количества цифр входного числа $n$ используется L-нотация (L-notation), а не стандартная запись полиномиального времени (например, $O(n^k)$). L-нотация определяется следующим образом:

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

Где $n$ — целое число, которое необходимо факторизовать, а $\ln n$ — натуральный логарифм, пропорциональный битовой длине $n$.

Если $\alpha = 0$: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$, что представляет полиномиальное время (Polynomial time) относительно битовой длины.
Если $\alpha = 1$: $L_n[1, c] = \exp(c \ln n) = n^c$, что представляет экспоненциальное время (Exponential time) относительно битовой длины.
Если $0 < \alpha < 1$: сложность находится между полиномиальным и экспоненциальным временем, образуя класс субэкспоненциального времени (Sub-exponential time).

Эволюция алгоритмов факторизации в прошлом по сути была историей постепенного уменьшения этого значения $\alpha$.

Метод цепных дробей (CFRAC) и метод множественного полиномиального квадратичного решета (MPQS): относятся к классу $\alpha = 1/2$, их сложность составляет примерно $L_n[1/2, 1]$.
Общий метод решета числового поля (GNFS): достигает $\alpha = 1/3$ и обладает невероятной сложностью $L_n[1/3, (64/9)^{1/3}]$, являясь самым быстрым среди известных классических алгоритмов в настоящее время.

3. Общая картина алгоритма и математическая структура GNFS (Общий метод решета числового поля)

GNFS имеет очень сложную и глубокую математическую базу. Основная идея является продолжением Малой теоремы Ферма и метода квадратичного решета (QS): она заключается в нахождении нетривиальной пары $(X, Y)$, удовлетворяющей сравнению $X^2 \equiv Y^2 \pmod n$ и при этом $X \not\equiv \pm Y \pmod n$, что позволяет вывести множитель числа $n$ как $\gcd(X-Y, n)$.

Однако суть GNFS состоит в том, что это делается не только в поле рациональных чисел $\mathbb{Q}$, но и путем одновременного поиска “гладких чисел (Smooth numbers)” как в поле расширения $\mathbb{Q}(\alpha)$, называемом алгебраическим числовым полем (Algebraic Number Field), так и в поле рациональных чисел, выстраивая отношения конгруэнтности через гомоморфизмы.

Процесс GNFS в основном делится на 5 этапов.

graph TD A["Проблема факторизации (Вход n)"] --> B["1. Выбор полинома (Polynomial Selection)"] B --> C["2. Просеивание (Sieving Phase)"] C --> D["3. Фильтрация (Filtering Phase)"] D --> E["4. Линейная алгебра (Linear Algebra Phase)"] E --> F["5. Извлечение квадратного корня (Square Root Phase)"] F --> G["Вывод простых множителей p, q"]

3.1 Этап 1: Выбор полинома (Polynomial Selection)

Успех GNFS во многом зависит от выбора подходящих полиномов. Цель — найти два неприводимых полинома $f_1(x)$ (на рациональной стороне) и $f_2(x)$ (на алгебраической стороне), имеющих общий корень $m$. То есть, они должны удовлетворять условию: $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$

Обычно для рациональной стороны выбирают линейный полином $f_1(x) = x - m$, а для алгебраической стороны $f_2(x)$ выбирают унитарный полином степени $d$ (чаще всего 5 или 6). Наиболее классическим подходом является метод Base-$m$. Выбирается целое число $m = \lfloor n^{1/(d+1)} \rfloor$, близкое к $1/(d+1)$-й степени $n$, и $n$ раскладывается по основанию $m$: $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ Таким образом мы получаем полином $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$. Очевидно, что $f_2(m) = n \equiv 0 \pmod n$.

Однако в современных реализациях используется алгоритм Кляйньюнга (Kleinjung’s algorithm). Он находит полиномы, оптимизирующие алгебраические свойства (значение Murphy’s $E$ или $\alpha$-value) и увеличивающие вероятность генерации гладких чисел на этапе просеивания, при этом не допуская чрезмерного увеличения коэффициентов полинома (оптимизация Skewness). В один только этот шаг вкладываются огромные вычислительные ресурсы.

3.2 Этап 2: Просеивание (Sieving Phase)

После того как полиномы определены, алгоритм переходит к этапу “просеивания (Sieving)”, который является самым вычислительно ресурсоемким. Здесь осуществляется поиск пар $(a, b)$. Эта пара взаимно проста, и требуется, чтобы следующие два значения одновременно были “гладкими (Smooth)”:

Норма на рациональной стороне: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
Норма на алгебраической стороне: $F_2(a, b) = b^d \cdot f_2(a/b)$

“Гладкий” означает, что число можно факторизовать, используя только простые числа, не превышающие заданного предела (Sieve bound). Подготавливаются базы простых чисел (Factor base) для рациональной и алгебраической сторон, и гладкие числа эффективно находятся в огромном пространстве поиска по принципу решета Эратосфена. В настоящее время основным методом является так называемое просеивание по решетке (Lattice Sieving), при котором фиксируется определенное простое число $q$, и просеиваются только те пары $(a, b)$ на подрешетке, для которых и рациональная, и алгебраическая стороны кратны $q$, что позволяет достичь крайне высокой эффективности.

3.3 Этап 3: Фильтрация (Filtering Phase)

Количество гладких соотношений (relations), найденных в процессе просеивания, достигает сотен миллионов или миллиардов. Однако многие из них содержат бесполезную информацию. Цель фильтрации — построить гигантскую разреженную матрицу (Sparse Matrix), одновременно минимизировав её размерность.

В частности, выполняются следующие операции:

Singleton removal: Удаление соотношений, содержащих простые множители, которые встречаются только один раз.
Clique removal / Merging: Перемножение соотношений, имеющих общие простые множители (встречающиеся 2 и более раз), для исключения переменных и сокращения в систему уравнений с более высокой плотностью, но меньшей размерности.

Благодаря этому матрица из миллиардов строк сжимается до гигантской разреженной матрицы $\mathbf{A}$ (элементы которой — 0 и 1 над полем $\mathbb{F}_2$) размером в десятки миллионов строк.

3.4 Этап 4: Линейная алгебра (Linear Algebra Phase)

Здесь мы находим нетривиальный вектор решений $\mathbf{x}$ уравнения $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$. Иными словами, это задача нахождения левого нуль-пространства (Left Nullspace) гигантской разреженной матрицы.

Поскольку размер матрицы экстремально велик, вычисления обычным методом Гаусса ($O(N^3)$) абсолютно невозможны. Поэтому используются итерационные методы, относящиеся к методам подпространства Крылова. Исторически использовался блочный метод Ланцоша (Block Lanczos), но в современных распределенных вычислительных средах доминирует блочный метод Видемана (Block Wiedemann Algorithm), способный радикально снизить накладные расходы на обмен данными.

Блочный метод Видемана вычисляет минимальный полином на основе матрицы $\mathbf{A}$ и последовательности векторов, а затем использует алгоритм Берлекэмпа-Мэсси (Berlekamp-Massey) для построения базиса нуль-пространства. Этот шаг крайне трудно поддается распараллеливанию и требует наличия суперкомпьютеров или тесно связанных коммуникационных сетей крупномасштабных кластеров, что является одним из главных узких мест GNFS.

3.5 Этап 5: Извлечение квадратного корня (Square Root Phase)

Из решений линейной алгебры конструируются произведения, которые образуют “полные квадраты” на рациональной и алгебраической сторонах. На рациональной стороне $\prod (a-bm)$ становится квадратом $X^2$ некоего целого числа $X$, а на алгебраической стороне произведение соответствующих идеалов образует полный квадрат $\gamma^2$ над алгебраическим полем. Вычисляя этот $\gamma$ в алгебраическом поле и применяя гомоморфизм $\phi: \alpha \mapsto m \pmod n$ в кольцо рациональных целых чисел, получаем сравнение: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$

Для изчисления квадратного корня над алгебраическим полем используются сложные алгоритмы, такие как метод Монтгомери (Montgomery’s Method), требующие глубоких знаний алгебраической теории чисел. В итоге вычисляется $\gcd(X-Y, n)$, и если найден нетривиальный множитель, факторизация завершена.

4. Существуют ли классические алгоритмы, превосходящие GNFS?

На сегодняшний день не обнаружено классического алгоритма факторизации произвольных целых чисел, асимптотическая сложность которого была бы ниже $L_n[1/3, c]$. Тем не менее, существуют некоторые попытки и производные алгоритмы, стремящиеся преодолеть теоретические и практические пределы.

4.1 Метод решета множественного числового поля (MNFS: Multiple Number Field Sieve)

В качестве расширения GNFS существует метод решета множественного числового поля (MNFS), предложенный Д. Копперсмитом. В то время как GNFS использует 2 полинома (рациональный и алгебраический), MNFS одновременно применяет несколько различных алгебраических полиномов для одного рационального полинома:

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

Использование нескольких алгебраических полей позволяет резко повысить вероятность того, что число окажется “гладким в каком-либо из алгебраических полей” на каждом этапе просеивания. Благодаря этому подходу Копперсмиту удалось незначительно уменьшить константу $c$ в сложности $L_n[1/3, c]$. В частности, теоретически доказано, что константа GNFS $c = (64/9)^{1/3} \approx 1.923$ при оптимизации с помощью MNFS может быть снижена примерно до $c \approx 1.902$. Однако на практике накладные расходы на управление множественными полями огромны, и это не привело к решающему прорыву для модулей RSA практических размеров.

4.2 Возможны ли алгоритмы класса $L_n[1/4]$?

Тема “Существуют ли алгоритмы с показателем $\alpha = 1/4$?” на протяжении многих лет остается предметом дебатов среди математиков, обсуждающих пределы классических алгоритмов факторизации. Текущий GNFS и его производные сильно привязаны к концепции “поиска гладкости” с помощью решета, и в рамках этой парадигмы широко распространено мнение, что $\alpha = 1/3$ является пределом. Анализ вероятности распределения гладких целых чисел с использованием функции Дикмана (Dickman function) также показывает, что при нынешних методах построения алгебраических полей в сочетании с решетом невозможно преодолеть барьер $O(L_n[1/3])$, как бы ни проводилась оптимизация.

Если алгоритм $L_n[1/4]$ или же классический алгоритм полиномиального времени действительно существует, он должен опираться на совершенно иную математическую структуру, не основанную на “поиске гладкости”, как GNFS (например, на более продвинутые подходы из алгебраической геометрии, подобные алгоритму Схофа (Schoof’s algorithm) для эллиптической криптографии), которую человечество пока не может себе представить. Однако в настоящее время предпосылок для этого не наблюдается.

5. Прорыв квантовых компьютеров: алгоритм Шора

В то время как классические компьютеры столкнулись с барьером $L_n[1/3]$, этот барьер был разрушен алгоритмом Шора (Shor’s Algorithm), опубликованным Питером Шором в 1994 году, который в корне изменил саму модель вычислений.

5.1 Шок квантового полиномиального времени

Алгоритм Шора сводит задачу факторизации к “задаче нахождения порядка (Order Finding Problem)”. Для заданного целого числа $a$ это задача нахождения периода (порядка) $r$ функции $f(x) = a^x \pmod n$. Классическому компьютеру требуется экспоненциальное время, чтобы найти этот период, но, используя квантовую оценку фазы (QPE: Quantum Phase Estimation) и квантовое преобразование Фурье (QFT: Quantum Fourier Transform) на квантовом компьютере, можно параллельно оценить суперпозицию всех состояний и с высокой вероятностью извлечь период $r$.

С точки зрения сложности, время выполнения алгоритма Шора относится к квантовому полиномиальному времени, а именно:

$$ O((\log n)^3) $$

С учетом последних оптимизаций схем считается, что эту величину можно сократить до $O((\log n)^2 \log \log n)$.

graph LR A["Классический алгоритм (GNFS)"] -->|Предел| B["Субэкспоненциальное время L_n[1/3]"] C["Квантовый алгоритм (Shor)"] -->|Прорыв| D["Полиномиальное время O((log n)^3)"] B --> E["Продолжение использования RSA (Увеличение длины ключа)"] D --> F["Полное разрушение RSA"]

5.2 Классическое субэкспоненциальное время против квантового полиномиального времени

Разница между этими двумя классами сложности имеет решающее значение для безопасности криптографии в реальном мире.

Например, рассмотрим случай факторизации RSA-2048 (составное число из 2048 бит).

GNFS (классический): при подстановке $n \approx 2^{2048}$ в $L_n[1/3, 1.923]$ потребуется примерно $2^{112}$ операций. Это астрономический объем вычислений, который займет время, превышающее возраст Вселенной, даже если объединить все вычислительные ресурсы, существующие сейчас на Земле.
Алгоритм Шора (квантовый): алгоритму $O((\log n)^3)$ потребуется около $2048^3 \approx 8.5 \times 10^9$ операций с логическими вентилями. Это означает, что при наличии подходящего оборудования (универсального квантового компьютера с миллионами физических кубитов и возможностью исправления ошибок) вычисления могут быть завершены всего за несколько часов или дней.

Смена парадигмы с субэкспоненциальной сложности с “показателем $\alpha=1/3$” на “полиномиальное время” делает традиционную криптографическую стратегию обеспечения безопасности за счет увеличения длины ключа неэффективной.

6. Заключение: Перспективы для следующего поколения

Текущий консенсус в научном сообществе по вопросу “Существуют ли классические алгоритмы, превосходящие GNFS?” таков:

Практические улучшения продолжаются, но асимптотических скачков не предвидится: Попытки улучшить константу $c$ в GNFS продолжаются, включая MNFS, оптимизацию выбора полиномов и распараллеливание метода Блока-Видемана. Однако вероятность открытия классического алгоритма со сложностью ниже $\alpha = 1/3$ считается крайне низкой.
Безопасность RSA на классических компьютерах остается надежной: Вычислительная сложность GNFS по-прежнему огромна, и RSA-2048 или RSA-4096 будут оставаться безопасными от атак на классических компьютерах в течение многих последующих десятилетий.
Истинная угроза исходит от квантовых алгоритмов: Барьер вычислительной сложности был преодолен алгоритмом Шора, основанным на принципах квантовой механики. Из-за этого мир вынужден переходить на постквантовую криптографию (PQC: Post-Quantum Cryptography). Переход к новым математическим проблемам, которые считаются сложными для решения (не могут быть решены за полиномиальное время) даже на квантовых компьютерах, таким как криптография на решетках и криптография на основе хешей, сегодня является передним краем криптографии.

Общий метод решета числового поля (GNFS) — это одна из “высших точек”, достигнутых человечеством в своем стремлении дойти до пределов классической математики и проектирования алгоритмов. Понимание глубокой математической структуры GNFS — это не просто изучение истории криптоанализа, но и путешествие в мир интеллектуальных исследований, позволяющее прикоснуться к красоте теории вычислительной сложности и алгебраической теории чисел. До того дня, когда квантовые компьютеры найдут практическое применение, GNFS, вероятно, будет продолжать удерживать трон как самый мощный алгоритм факторизации простых чисел.

【Иллюстрированное руководство по PQC】Сравнение основных алгоритмов постквантовой криптографии

Fri, 11 Sep 2026 07:00:00 +0900

1. Введение: «Криптографический кризис», вызванный квантовыми компьютерами

В современном интернет-обществе криптография с открытым ключом является незаменимой инфраструктурой для защиты конфиденциальности связи и целостности данных. Безопасность широко используемых сегодня алгоритмов RSA и криптографии на эллиптических кривых (ECC) опирается на математические барьеры — «сложность факторизации больших составных чисел» и «сложность задачи дискретного логарифмирования на эллиптических кривых» соответственно. Доказано, что классическим компьютерам (компьютерам, которые мы используем сейчас, включая суперкомпьютеры) для решения этих математических задач потребовалось бы время, превышающее возраст Вселенной, и это служило основой их безопасности.

Однако эта надежная предпосылка может быть разрушена до основания из-за развития теории и практического применения квантовых компьютеров. В 1994 году криптограф Питер Шор (Peter Shor) представил «Алгоритм Шора», который теоретически доказал, что при запуске на отказоустойчивом универсальном квантовом компьютере (CRQC: Cryptographically Relevant Quantum Computer) достаточной мощности, задачи факторизации и дискретного логарифмирования могут быть решены за «полиномиальное время». Это означает, что все используемые в настоящее время алгоритмы криптографии с открытым ключом будут нейтрализованы.

graph TD A["Крупномасштабный квантовый компьютер (CRQC)"] -->|Запуск| B["Алгоритм Шора"] B -->|Взлом за полиномиальное время| C["Задача факторизации (RSA)"] B -->|Взлом за полиномиальное время| D["Задача дискретного логарифмирования (ECC / ECDSA)"] C --> E["Прослушивание связи, подделка данных, спуфинг"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Считать, что «полноценные квантовые компьютеры появятся еще через несколько десятилетий, поэтому проблем нет» — крайне опасно. Причина в том, что метод атаки, известный как Store Now, Decrypt Later (SNDL: Сохрани сейчас, расшифруй потом), уже стал реальной угрозой. Это атака, при которой враждебные государства или хакерские организации сохраняют огромные объемы текущих зашифрованных данных связи (например, TLS-трафик) в хранилища, чтобы расшифровать их все в тот момент, когда в будущем станет доступен мощный квантовый компьютер. Государственные секреты, инфраструктурная информация и медицинские данные, требующие долгосрочной защиты, уже подвержены этой угрозе.

Кроме того, для симметричной криптографии (например, AES) и хеш-функций (например, SHA-256) существует Алгоритм Гровера, открытый в 1996 году. Он сокращает вычислительную сложность атаки полным перебором (брутфорс) до квадратного корня. Другими словами, уровень безопасности AES-128 фактически снижается вдвое — до 2 в 64-й степени, поэтому в квантовую эру рекомендуется использовать более длинные ключи и хеши, такие как AES-256 и SHA-384.

Для противодействия этому беспрецедентному криптографическому кризису была создана постквантовая криптография (Post-Quantum Cryptography: PQC), основанная на новых математических задачах, которые трудно решить даже с помощью квантовых компьютеров. В этой статье, основываясь на результатах процесса стандартизации PQC, проведенного Национальным институтом стандартов и технологий США (NIST), мы подробно рассмотрим основные алгоритмы PQC — от их математических основ до механизмов работы и сравнения архитектур.

2. Обзор и история проекта по стандартизации PQC от NIST

Переход на новые криптографические технологии, включая перепроектирование протоколов, обновление систем и замену оборудования, занимает от нескольких лет до десятилетий. Поэтому криптографы во всем мире заранее начали исследования в области PQC. Центральную роль в этом сыграл NIST (Национальный институт стандартов и технологий) США. В 2016 году NIST объявил о начале процесса стандартизации PQC и начал принимать предложения совершенно новых криптографических алгоритмов от мирового криптографического сообщества.

Объектами стандартизации стали две основные категории:

Криптография с открытым ключом / Механизм инкапсуляции ключа (KEM: Key Encapsulation Mechanism): Механизм для безопасного обмена (доставки) симметричных ключей, используемых для шифрования каналов связи, например, при TLS-соединениях.
Цифровые подписи (Digital Signatures): Механизм для проверки отсутствия фальсификации данных и предотвращения подмены отправителя (аутентичность) при обновлениях программного обеспечения или в цифровых сертификатах.

После почти шести лет интенсивной оценки, анализа и соревнований по взлому (раунды 1–3), а также дополнительной оценки некоторых алгоритмов в раунде 4, следующие алгоритмы были официально выпущены в качестве Федеральных стандартов обработки информации (FIPS) в 2024 году и утверждены как будущие мировые стандарты:

FIPS 203 (ML-KEM): KEM на базе CRYSTALS-Kyber
FIPS 204 (ML-DSA): Цифровая подпись на базе CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Цифровая подпись на основе хешей без сохранения состояния на базе SPHINCS+
(Ожидается в будущем) FN-DSA: Цифровая подпись на базе FALCON

Выбранные алгоритмы опираются на различные математические «задачи о сложности», что обеспечивает разнообразие (Crypto Agility), чтобы в случае обнаружения критической уязвимости в одном алгоритме вся система не рухнула. В процессе стандартизации криптография на решетках (Lattice-based cryptography) стала главным героем с точки зрения производительности, но криптография на основе хешей и кодов была принята в качестве надежного резерва.

3. Классификация основных математических подходов PQC

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

Криптография на решетках (Lattice-based Cryptography): Основана на задаче нахождения кратчайшего вектора (SVP), задаче нахождения ближайшего вектора (CVP) в многомерном пространстве решеток, а также на производной от них задаче LWE. Это ядро стандартизации NIST, к которому относятся Kyber, Dilithium и FALCON. Они предлагают лучший баланс между скоростью обработки, размером открытого ключа и размером шифротекста, что делает их подходящими для общего использования.
Криптография на основе хешей (Hash-based Cryptography): Безопасность опирается исключительно на «устойчивость к коллизиям» и «односторонность» криптографических хеш-функций (таких как SHA-2 или SHAKE). Применима только для цифровых подписей (например, SPHINCS+), но характеризуется наиболее строгим доказательством безопасности и чрезвычайно высокой устойчивостью к неизвестным математическим атакам.
Криптография на основе кодов (Code-based Cryptography): Основана на теории кодов с исправлением ошибок и опирается на сложность задачи синдромного декодирования (Syndrome Decoding Problem). Типичным представителем является Classic McEliece, предложенный в 1970-х годах. Обладает долгой историей и доказанной безопасностью, но при этом имеет крайне большие размеры открытых ключей (в мегабайтах).
Многомерная полиномиальная криптография (Multivariate Polynomial Cryptography): Основана на сложности решения системы нелинейных уравнений со многими переменными над конечным полем (задача MQ). Предлагалась в основном для цифровых подписей (например, Rainbow), но во время финального раунда NIST был обнаружен мощный метод атаки, позволивший взломать ее на обычном ПК за несколько дней, из-за чего многие алгоритмы выбыли из процесса стандартизации.
Криптография на основе изогений (Isogeny-based Cryptography): Основана на задаче поиска пути в графах изогений эллиптических кривых. Имела очень маленький размер ключа и ожидалась как достойный преемник ECC, однако в 2022 году финалист «SIKE» был полностью взломан всего за несколько часов на обычном ПК с использованием классической математики (атака Castryck-Decru), что стало драматичным финалом, символизирующим сложность и опасность проектирования PQC.

4. Глубины криптографии на решетках: задача LWE и математические основы Module-LWE

В настоящее время наиболее перспективной и ставшей ядром стандартизации является криптография на решетках. В основе ее безопасности лежит задача LWE (Learning with Errors: Обучение с ошибками). Она была предложена Одедом Регевом (Oded Regev) в 2005 году, и за это прорывное достижение он был удостоен премии Гёделя. Невозможно говорить о современной PQC без понимания задачи LWE.

4.1. Что такое задача LWE (Learning with Errors)?

Сначала рассмотрим простую систему линейных уравнений. Предположим, по модулю $q$ даны известная случайная матрица $A$, неизвестный секретный вектор $\vec{s}$ и их произведение $\vec{b}$:

$$ \vec{b} = A\vec{s} \pmod q $$

В этом случае, найти неизвестный $\vec{s}$ из открытой информации $A$ и $\vec{b}$ довольно просто. Используя классический алгоритм «метод Гаусса», можно легко вычислить $\vec{s}$ за полиномиальное время.

Однако, если добавить к этому уравнению «небольшую преднамеренную ошибку (шум)», сложность задачи резко возрастает. Это и есть задача LWE.

Имеется неизвестный секретный вектор $\vec{s} \in \mathbb{Z}_q^n$ и случайно выбранная матрица $A \in \mathbb{Z}_q^{m \times n}$. Кроме того, подготавливается вектор ошибок $\vec{e} \in \mathbb{Z}_q^m$ с «достаточно малыми значениями элементов», выбранными в соответствии с нормальным или биномиальным распределением, и $\vec{b}$ вычисляется следующим образом:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Поисковая задача LWE (Search LWE) заключается в нахождении секретной информации $\vec{s}$ из открытых данных $(A, \vec{b})$. Из-за присутствия ошибки $\vec{e}$ попытки применить алгебраические методы, такие как метод Гаусса, терпят неудачу: в процессе сложения и вычитания уравнений ошибка $\vec{e}$ нарастает, как снежный ком, и в конечном итоге результат становится неотличимым от случайных значений.

Величие задачи LWE заключается в наличии сильного теоретического доказательства (сведения), согласно которому, если не существует квантового алгоритма, способного решить задачи на решетках в худшем случае (Worst-case hardness), такие как GapSVP и SIVP, то задачу LWE невозможно решить в среднем случае (Average-case). Это означает, что даже случайно сгенерированные криптографические ключи обладают надежной безопасностью, подкрепленной теоретическими пределами.

4.2. Радикальное повышение эффективности с помощью Ring-LWE и Module-LWE

Стандартная задача LWE (Standard LWE) имеет очень четкие основания для безопасности, но матрица $A$ становится слишком большой, а размер ключа достигает мегабайтов, что делает ее непрактичной. В связи с этим был предложен подход, использующий кольца многочленов (Polynomial Rings) для создания алгебраической структуры.

В задаче Ring-LWE вместо обычных векторов и матриц используются элементы (многочлены) некоего кольца многочленов $R_q$. В стандартах NIST обычно используется следующее круговое кольцо многочленов:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Здесь $n$ — степень двойки (например, 256), а $q$ — подходящее простое число. В этом кольце используются элементы $a, s, e \in R_q$ для вычисления $b = a \cdot s + e \pmod q$. Поскольку один многочлен $a$ имеет $n$ коэффициентов, данные можно значительно сжать. Кроме того, использование NTT (Number Theoretic Transform: Теоретико-числовое преобразование), версии быстрого преобразования Фурье (FFT) для конечных полей, позволяет сверхбыстро умножать многочлены с вычислительной сложностью $O(n \log n)$.

Однако в случае с Ring-LWE существовали опасения, что «могут существовать неизвестные уязвимости из-за специфической алгебраической структуры кольца». Кроме того, при изменении уровня безопасности (эквивалентно AES-128, 192, 256 и т.д.) было необходимо изменять саму степень многочлена $n$, что влекло за собой инженерную проблему полного переписывания реализации, включая алгоритм NTT.

В связи с этим алгоритмы, прошедшие стандартизацию (Kyber и Dilithium), приняли задачу Module-LWE (M-LWE). Module-LWE — это компромисс между бесструктурным Standard LWE и слишком структурированным Ring-LWE. Он использует матрицу (модуль) размера $k \times k$, элементами которой являются элементы кольца многочленов $R_q$:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Главное преимущество Module-LWE заключается в том, что при фиксированной степени многочлена $n$ (в стандартах NIST $n=256$) можно легко масштабировать уровень безопасности, просто изменяя размерность матрицы $k$. Например, в Kyber размерность $k$ регулируется следующим образом:

Kyber512 (Level 1): $k = 2$ (эквивалентно AES-128)
Kyber768 (Level 3): $k = 3$ (эквивалентно AES-192)
Kyber1024 (Level 5): $k = 4$ (эквивалентно AES-256)

Это позволило на 100% повторно использовать базовый код NTT и аппаратные схемы для полиномиальных вычислений на всех уровнях безопасности, что радикально повысило безопасность и эффективность реализации.

5. CRYSTALS-Kyber (ML-KEM): Механизм инкапсуляции ключа следующего поколения

Официально стандартизированный как FIPS 203 (ML-KEM), CRYSTALS-Kyber представляет собой механизм инкапсуляции ключа (KEM), основанный на задаче Module-LWE, описанной выше. В будущем он станет де-факто мировым стандартом для безопасного обмена сессионными ключами в TLS 1.3, SSH и других протоколах.

5.1. Архитектура KEM (Key Encapsulation Mechanism)

В эру PQC стандартом станет не прямой подход, как в RSA, где «клиент создает симметричный ключ, шифрует его открытым ключом сервера и отправляет», а концепция инкапсуляции, называемая KEM.

sequenceDiagram participant Client as "Клиент (Alice)" participant Server as "Сервер (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Генерирует секретный ключ (sk) и открытый ключ (pk)" Client->>Server: "Отправляет открытый ключ (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Генерирует случайный симметричный ключ (K)" Server->>Server: "Инкапсулирует K с помощью pk, создавая шифротекст (c)" Server->>Client: "Отправляет шифротекст (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Расшифровывает шифротекст (c) с помощью секретного ключа (sk)" Client->>Client: "Снимает инкапсуляцию, извлекая симметричный ключ (K)" Note over Client, Server: "Начинает защищенную связь (например, AES), используя общий симметричный ключ (K)"

5.2. Внутренние механизмы алгоритма Kyber и преобразование Фудзисаки-Окамото

Дизайн Kyber очень утонченный. Сначала создается схема криптографии с открытым ключом, устойчивая только к CPA (атака на основе выбранного открытого текста) — Kyber.CPAPKE. Затем к ней применяется мощный криптографический метод, известный как преобразование Фудзисаки-Окамото (Fujisaki-Okamoto Transform), благодаря которому схема превращается в полноценный KEM, устойчивый к CCA (адаптивная атака на основе выбранного шифротекста).

Основной механизм шифрования и дешифрования CPAPKE выглядит следующим образом:

Генерация ключей (Key Generation):
- Из случайного значения сида генерируется матрица $A \in R_q^{k \times k}$ в домене NTT. Используется модуль $q = 3329$.
- Из центрированного биномиального распределения (CBD) берутся секретный вектор $\vec{s}$ и вектор ошибок $\vec{e}$ с малыми коэффициентами.
- Вычисляется $\vec{t} = A\vec{s} + \vec{e}$. Открытый ключ — это $(A, \vec{t})$, секретный ключ — $\vec{s}$. (На практике $A$ раскрывается в виде сида для экономии пропускной способности).
Шифрование (Encryption):
- 32-байтное сообщение $m$ (материал для симметричного ключа), которым необходимо обменяться, кодируется в многочлен.
- Генерируются новый случайный вектор $\vec{r}$ и малые ошибки $\vec{e_1}, e_2$.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- Шифротекстом является пара $(\vec{u}, v)$.
Дешифрование (Decryption):
- Получатель вычисляет $v - \vec{s}^T\vec{u}$.
- При разложении формулы получаем: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Подставив $\vec{t} = A\vec{s} + \vec{e}$, главный член $\vec{s}^TA^T\vec{r}$ сокращается.
- Остается: $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Члены в скобках — это «произведения и суммы малых ошибок», поэтому в целом они остаются достаточно малыми (шумом). Следовательно, путем проверки того, близок ли каждый коэффициент к $0$ или к $q/2$, можно полностью и безошибочно восстановить биты (0 или 1) исходного сообщения $m$.

Главными преимуществами Kyber являются его потрясающая скорость обработки и умеренный размер ключа. Для Kyber768 размер открытого ключа составляет 1184 байта, а размер шифротекста — 1088 байт. И хотя они больше по сравнению с RSA-3072 (размер ключа около 384 байт), они помещаются в MTU (Maximum Transmission Unit) современных интернет-сетей без фрагментации пакетов и практически не влияют на сетевые задержки.

6. CRYSTALS-Dilithium (ML-DSA): Универсальная цифровая подпись на основе решеток

В процессе стандартизации цифровых подписей соревновались алгоритмы с различными концептуальными дизайнами в рамках подхода криптографии на решетках. Среди них в качестве универсальной цифровой подписи FIPS 204 (ML-DSA) был выбран CRYSTALS-Dilithium.

6.1. Парадигма Fiat-Shamir with Aborts

Dilithium, как и Kyber, является схемой цифровой подписи на основе Module-LWE (а также задачи Module-SIS). В основе его дизайна лежит критически важная парадигма «Fiat-Shamir with Aborts (Преобразование Фиата-Шамира с прерываниями)».

Само по себе преобразование Фиата-Шамира является стандартным методом для преобразования интерактивного протокола доказательства с нулевым разглашением в неинтерактивную цифровую подпись. Доказывающий (подписант) генерирует обязательство $y$, вычисляет $w = Ay$ и пропускает через хеш-функцию, чтобы получить случайный запрос $c$, и вычисляет ответ $z = y + cs$.

Однако при простом применении этого метода в криптографии на решетках распределение ответа $z$ искажается в зависимости от значения секретного ключа $s$, что приводит к критической проблеме (математическая утечка типа побочного канала), когда атакующий, анализируя множество подписей, постепенно получает информацию о секретном ключе $s$.

Команда разработчиков Dilithium (Любашевский и др.) внедрила метод «выборки с отклонением (Rejection Sampling)», при котором, если коэффициенты вычисленного результата подписи $z$ не попадают в заранее заданный безопасный пороговый диапазон, весь процесс подписания прерывается (Abort), и вычисления начинаются заново с новым случайным числом $y$.

В результате окончательно выдаваемая подпись $z$ имеет абсолютно равномерное распределение, не зависящее от секретного ключа, что математически полностью предотвращает утечку информации.

6.2. Преимущества Dilithium и простота реализации

Огромное преимущество дизайна Dilithium заключается в том, что в процессе создания подписи вообще не используется сложная «выборка из гауссовского распределения» или «вычисления с плавающей запятой». Поскольку алгоритм может быть реализован с использованием только выборки из равномерного распределения, простых модульных целочисленных вычислений, NTT и хеш-функций (SHAKE), его легко безопасно реализовать за константное время (Constant-time) в самых разных средах — от встроенных микроконтроллеров до облачных серверов. Это также обеспечивает надежную защиту от физических атак по сторонним каналам, таких как атаки по времени.

7. FALCON (FN-DSA): Ультракомпактная решеточная подпись

NIST выбрал FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) как еще одного кандидата на стандартизацию подписи на решетках, обладающего характеристиками, отличными от Dilithium (в настоящее время разрабатывается черновик стандарта FN-DSA).

7.1. Решетки NTRU и гауссовская выборка

Главной особенностью FALCON является использование исторически более старых (существующих с 1996 года) решеток NTRU (N-th degree Truncated polynomial Ring Units) вместо задачи LWE. Кроме того, в нем используется парадигма «Hash-and-Sign (Хешируй и подписывай)», основанная на фреймворке GPV (Gentry-Peikert-Vaikuntanathan).

В Hash-and-Sign хеш сообщения служит целевой точкой в пространстве, а подписью является нахождение ближайшей к ней точки решетки (приближенное решение задачи нахождения ближайшего вектора). Для этого требуется выборка точек в соответствии с дискретным гауссовским распределением, используя секретный ключ — «качественный короткий базис».

FALCON радикально ускорил эти тяжелые вычисления с помощью метода, известного как «Быстрая ортогонализация Фурье (Fast Fourier Orthogonalization: FFO)».

7.2. Преимущества и недостатки FALCON

Огромным преимуществом FALCON является его чрезвычайно маленький размер подписи и открытого ключа (компактность). В то время как размер подписи Dilithium3 составляет около 3309 байт, размер подписи FALCON-512 — всего около 666 байт. Открытый ключ также очень мал — 897 байт. Это делает его настоящим спасением в условиях с жесткими ограничениями пропускной способности, для IoT-устройств и специфических сетевых протоколов.

Однако существует и серьезный недостаток. Поскольку при генерации подписи требуется дискретная гауссовская выборка, включающая сложные вычисления с плавающей запятой (64-bit IEEE 754), реализовать ее за константное время (Constant-time implementation) для предотвращения утечек по времени крайне сложно, и размер кода становится огромным. По этой причине FALCON позиционируется как мощный специализированный алгоритм для конкретных применений, в отличие от универсального Dilithium.

graph LR A["Требования к цифровой подписи"] --> B{"Каковы главные ограничения?"} B -->|"Простота реализации, универсальность, простота реализации константного времени"| C["Dilithium (ML-DSA)"] B -->|"Минимизация полосы пропускания связи, компактность размера данных"| D["FALCON (FN-DSA)"] C --> E["Универсальные сертификаты TLS, электронная подпись программного обеспечения"] D --> F["Протоколы со строгими ограничениями на размер пакета, специальные среды"]

8. SPHINCS+ (SLH-DSA): Подпись на основе хешей с высочайшим уровнем безопасности

На случай худшего сценария, при котором безопасность решеточной криптографии будет нарушена в будущем из-за прорыва гениальных математиков, NIST разработал стандарт FIPS 205 (SLH-DSA), или SPHINCS+, с совершенно иным подходом.

SPHINCS+ относится к категории подписей на основе хешей. Его безопасность опирается исключительно на один факт: «используемая криптографическая хеш-функция (например, SHA-2 или SHAKE256) обладает устойчивостью к коллизиям и односторонностью». Поскольку он не зависит от математических задач с определенной алгебраической структурой, таких как LWE или факторизация, какие бы мощные квантовые алгоритмы ни появились в будущем, им можно будет противостоять простым увеличением длины выхода хеш-функции. Это обеспечивает чрезвычайно надежную безопасность (наиболее консервативную защиту).

8.1. Архитектура без сохранения состояния (stateless) с использованием WOTS+ и FORS

История подписей на основе хешей давняя и восходит к подписи Лэмпорта и одноразовой подписи Винтерница (WOTS) в 1970-х годах. Это были одноразовые ключи, позволяющие «безопасно подписать только один раз». Чтобы сделать возможным их многократное использование, были разработаны алгоритмы XMSS (eXtended Merkle Signature Scheme) и LMS, которые с помощью деревьев Меркла (Merkle Tree) управляли бесчисленным количеством одноразовых ключей под одним корневым хешем.

Однако у XMSS и LMS был серьезный недостаток — они были «stateful (с сохранением состояния)». При каждом создании подписи необходимо было строго фиксировать в энергонезависимой памяти индекс («какой по счету одноразовый ключ был использован»). Если в результате восстановления снимка виртуальной машины состояние откатывалось назад, и один и тот же ключ использовался дважды, секретный ключ мгновенно утекал, и система рушилась.

SPHINCS+ решает эту проблему управления состоянием и является stateless (не требующей сохранения состояния) подписью на основе хешей. В основе его технологии лежит следующая комбинация:

WOTS+ (Winternitz One-Time Signature Plus): Базовая одноразовая подпись.
FORS (Forest of Random Subsets): Технология подписи с ограниченным числом использований (Few-Time Signature). Сохраняет безопасность, даже если один и тот же ключ используется несколько раз.
Hyper-Tree (Гипердерево): Гигантская структура, состоящая из многоуровнево вложенных деревьев Меркла.

При создании подписи в SPHINCS+ вместо управления состоянием используется псевдослучайное число для случайного выбора одного из огромного числа ключей FORS в основании Hyper-Tree. Поскольку количество листьев дерева астрономически велико, вероятность случайного выбора одного и того же ключа дважды (коллизия) ничтожно мала, что в итоге позволяет реализовать подход без сохранения состояния.

Единственным и самым большим недостатком SPHINCS+ является очень большой размер подписи. В зависимости от параметров он может достигать от 17 КБ до 49 КБ, а скорость генерации подписи значительно ниже по сравнению с решеточной криптографией. Поэтому ожидается, что алгоритм будет применяться не в повседневном веб-браузинге, а в сценариях, требующих долгосрочной абсолютной безопасности и не требующих частого подписания, например, в подписях обновлений ПО или сертификатах корневых удостоверяющих центров (CA).

9. Криптография на основе кодов: старый добрый гигант Classic McEliece

В процессе стандартизации NIST важным подходом, который все еще оценивается в качестве финалиста Раунда 4, является алгоритм Classic McEliece, относящийся к криптографии на основе кодов.

Предложенный Робертом МакЭлисом (Robert McEliece) в 1978 году, этот алгоритм является одним из старейших в истории криптографии с открытым ключом, наряду с RSA. Он использует алгебро-геометрические коды, называемые «кодами Гоппы», и основан на «задаче синдромного декодирования (Syndrome Decoding Problem)»: к сообщению преднамеренно добавляется ошибка (вектор шума) для его шифрования, а восстановить исходное сообщение, удалив ошибку с помощью мощных возможностей исправления, может только тот, у кого в качестве секретного ключа есть проверочная матрица кода Гоппы.

$$ \vec{c} = \vec{m} G + \vec{e} $$

(где $G$ — скремблированная порождающая матрица, являющаяся открытым ключом, а $\vec{e}$ — вектор ошибки веса $t$)

Удивительно в Classic McEliece то, что прошло более 40 лет с момента его создания, он подвергался интенсивным исследованиям по взлому криптографами со всего мира, но при этом ни разу не была обнаружена его фундаментальная уязвимость — это колоссальный послужной список. Из всех алгоритмов PQC он обладает самой «проверенной временем надежной безопасностью».

Кроме того, есть преимущество: размер шифротекста очень мал (всего около 100–200 байт). Однако у него есть критический недостаток — размер открытого ключа измеряется мегабайтами (МБ). Даже на самом низком уровне безопасности (эквивалентно AES-128) открытый ключ составляет около 250 КБ, а на высоких уровнях превышает 1 МБ.

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

10. Сравнение производительности и компромиссы алгоритмов PQC

В таблице ниже приведены характеристики производительности основных алгоритмов, обсуждавшихся до сих пор, на общих уровнях безопасности (эквивалентно NIST Level 2–3, уровень AES-128–192).

Алгоритм (Стандартное имя)	Категория	Математическая основа	Размер открытого ключа	Размер секретного ключа	Размер шифротекста/подписи	Тенденция скорости обработки	Основные характеристики и применения
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	Очень высокая	Лучший баланс размера ключа и скорости. Универсальный стандарт KEM для TLS 1.3 и др.
Dilithium3 (ML-DSA)	Подпись	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	Генерация и верификация быстрые	Простая реализация. Универсальный стандарт цифровой подписи.
FALCON-512 (FN-DSA)	Подпись	Решетка NTRU	897 Bytes	1,281 Bytes	666 Bytes	Медленная генерация подписи, сверхбыстрая верификация	Минимальный размер подписи. Требует вычислений с плавающей запятой. Для встраиваемых систем и IoT.
SPHINCS+ (SLH-DSA)	Подпись	Хеш-функция	32 Bytes	64 Bytes	Ок. 17,000 Bytes	Очень медленная генерация	Риск математического взлома близок к нулю. Для высокосекретных применений (корневые сертификаты).
Classic McEliece	KEM	Код Гоппы	Ок. 1.04 MB	13,568 Bytes	188 Bytes	Быстрая инкапсуляция	40 лет доказанной безопасности. Огромный открытый ключ. Для сред с возможностью хардкодинга.

Понимание компромиссов

В мире PQC не существует единого волшебного алгоритма, который был бы «маленьким, быстрым и имел безупречные математические гарантии».

Стандарт интернета (Kyber / Dilithium): Предлагает наилучший баланс производительности и лучше всего подходит для прозрачной замены (drop-in replacement) текущих RSA/ECC.
Предельный консерватизм (SPHINCS+): Выбирается в тех случаях, когда требуется абсолютная страховка от будущих математических прорывов, даже ценой увеличения размера данных и снижения скорости.
Для особых сред (FALCON / Classic McEliece): Специализированное оружие, выбираемое в зависимости от ограничений среды — например, при крайне узкой полосе пропускания связи или при возможности предварительного распространения ключей.

11. Проблемы практического применения и реалистичное решение: «Гибридная криптография»

С завершением стандартизации NIST и официальным выпуском стандартов FIPS, в IT-инфраструктуре по всему миру стартовал полномасштабный переход на PQC (PQC-миграция). Браузер Google Chrome, сервис Apple iMessage (протокол PQ3) и сетевые провайдеры вроде Cloudflare уже внедрили поддержку PQC в свои протоколы и начали их практическое использование.

Однако полный и резкий переход на новые криптографические алгоритмы сопряжен с очень высокими рисками. Если предположить, что через несколько лет какой-нибудь гениальный математик обнаружит критический метод атаки на решеточные алгоритмы, такие как Kyber (математический дефект, позволяющий взломать его даже на классическом компьютере), то вся система, зависящая от него, мгновенно окажется уязвимой.

Реалистичным и рекомендуемым подходом для смягчения риска этой неопределенности является «Гибридная криптография (Hybrid Cryptography)».

В гибридной криптографии для обмена ключами одновременно используются как проверенные годами классические алгоритмы (например, эллиптическая кривая X25519), так и новые PQC-алгоритмы (например, Kyber768). Каждый алгоритм генерирует компоненты симметричного ключа независимо друг от друга, а затем эти два компонента смешиваются с помощью безопасной функции формирования ключа (KDF) для создания окончательного мастер-ключа.

graph TD A["Клиент"] -->|① Отправляет открытый ключ X25519 + открытый ключ Kyber| B["Сервер"] B -->|② Отправляет общий ключ X25519 + инкапсулированный шифротекст Kyber| A A --> C{"Вывод мастер-ключа (KDF)"} B --> C C -->|Вход: (симметричный ключ X25519) || (симметричный ключ Kyber)| D["Защищенный ключ связи (AES-256 / ChaCha20)"] D -->|"Устойчивость к квантовым угрозам И классическим уязвимостям"| E["Защищенная гибридная зашифрованная связь (TLS 1.3)"]

Это обеспечивает надежную двухуровневую безопасность: «в случае появления квантового компьютера и взлома ECC, Kyber защитит связь», и наоборот: «в случае обнаружения неизвестного математического дефекта в Kyber, ECC защитит связь». Ярким примером является проект стандарта X25519MLKEM768 (ранее X25519Kyber768), разрабатываемый в IETF; в настоящее время обмен данными между современными веб-браузерами и серверами осуществляется именно по этому гибридному методу.

Кроме того, в системном проектировании концепция Crypto Agility (криптографической гибкости) — архитектура, которая «не слишком зависит от конкретного криптографического алгоритма и может быстро переключиться на другой алгоритм в случае его компрометации (например, от Kyber к McEliece или от Dilithium к SPHINCS+)» — станет обязательным требованием при разработке будущих систем.

12. Заключение: Новые горизонты криптографии

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

Завершение стандартизации алгоритмов FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) и FIPS 205 (SLH-DSA) институтом NIST — это не финиш. Это лишь первый шаг в грандиозном путешествии PQC-миграции, которое продлится десятилетия. Для инженеров-программистов и системных архитекторов главной технической задачей в будущем станет то, как оптимально адаптировать сетевые протоколы и системы к «увеличению размера ключей» и «изменениям вычислительных затрат», вызванных этими новыми алгоритмами.

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

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard