Mathematics 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.

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

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

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

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

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

Быстрый алгоритм проверки на простоту, реализованный на C++ (метод Миллера-Рабина и др.)

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

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

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

Кроме того, в спортивном программировании (AtCoder, Codeforces и др.) проверка на простоту — часто встречающаяся тема. Для огромных входных данных с ограничениями вида $N \le 10^{18}$, когда требуется десятки тысяч раз проверить числа на простоту за 1 секунду, традиционные наивные алгоритмы не уложатся в лимит времени (Time Limit Exceeded: TLE).

В этой статье мы подробно разберем всё от математических основ до высокооптимизированной реализации на C++: начиная с наивного алгоритма, вероятностного метода проверки простоты «тест Ферма» и заканчивая практичным сверхбыстрым алгоритмом «Тест Миллера-Рабина (Miller-Rabin)», который преодолевает его слабые стороны. В частности, для 64-битных целых чисел ($N < 2^{64}$) мы подробно объясним метод «100% достоверной проверки (детерминированный алгоритм)», выходящий за рамки вероятностной оценки, и предоставим готовый к использованию исходный код на C++.

1. Основы проверки на простоту и метод пробных делений (Trial Division)

Простое число (Prime number) — это натуральное число больше 1, которое не имеет положительных делителей, кроме 1 и самого себя. Строго следуя определению, чтобы проверить, является ли целое число $N$ простым, можно попробовать разделить $N$ на все целые числа от $2$ до $N-1$. Если оно ни разу не разделится без остатка, то это простое число, а если разделится хотя бы раз — составное число (не простое).

Однако вычислительная сложность этого метода составляет $O(N)$, и если $N$ — огромное число, например $10^{18}$, то даже на современном компьютере вычисления займут колоссальное количество времени.

Оптимизация метода пробных делений: поиск до $\sqrt{N}$

Если составное число $N$ можно выразить как $a \times b = N$ (где $a \le b$), то обязательно $a \le \sqrt{N}$. Следовательно, цикл проверки не нужно выполнять до $N-1$, достаточно проверить до $\sqrt{N}$.

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


#include <iostream>

// Проверка на простоту методом пробных делений (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // Проверяем только нечетные числа, начиная с 3
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

Вычислительная сложность этого алгоритма — $O(\sqrt{N})$. Для $N \le 10^{12}$ вычисления выполняются мгновенно, но при $N \approx 10^{18}$ количество итераций цикла составит около $10^9$, что даже в C++ потребует от сотен миллисекунд до нескольких секунд. Поэтому этот метод не подходит для многократных проверок.

2. Тест Ферма: Начало вероятностной проверки на простоту

Чтобы преодолеть ограничения метода пробных делений, были придуманы «вероятностные алгоритмы» (Probabilistic Algorithm), использующие теоремы теории чисел. Ярким примером является «Тест Ферма на простоту» (Fermat Primality Test), основанный на малой теореме Ферма.

Малая теорема Ферма (Fermat’s Little Theorem)

Эта теорема, открытая Пьером де Ферма (Pierre de Fermat), утверждает следующее:

Для любого простого числа $p$ и любого целого числа $a$, взаимно простого с $p$ (не кратного $p$), выполняется следующее сравнение:
$$ a^{p-1} \equiv 1 \pmod p $$

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

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

Для выполнения теста Ферма необходимо быстро вычислить огромную степень $a^{N-1} \pmod N$. Для этого используется «метод бинарного возведения в степень» (Modular Exponentiation / Binary Exponentiation). Его вычислительная сложность составляет $O(\log N)$, что делает его очень быстрым.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Вычисление a^b mod m с помощью бинарного возведения в степень
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

Здесь для предотвращения переполнения используется расширение GCC/Clang __int128_t (128-битное целое число) для хранения промежуточных произведений.

Псевдопростые числа и числа Кармайкла (Carmichael Numbers)

Тест Ферма очень мощный, но у него есть фатальный недостаток. Существуют такие составные числа $N$, для которых выполняется $a^{N-1} \equiv 1 \pmod N$ при всех $a$, взаимно простых с $N$.

Такие числа называются «абсолютно псевдопростыми» или «числами Кармайкла». Наименьшее число Кармайкла — $561 = 3 \times 11 \times 17$. Из-за существования чисел Кармайкла с помощью только теста Ферма невозможно провести детерминированную проверку со «100% вероятностью». Сколько бы различных $a$ мы ни пробовали, такие числа, как $561$, всегда будут притворяться (обманывать) простыми.

3. Тест простоты Миллера-Рабина (Miller-Rabin Primality Test)

Алгоритм, блестяще преодолевший недостаток теста Ферма (существование чисел Кармайкла), — это «тест простоты Миллера-Рабина», предложенный Миллером (Gary L. Miller) и Рабином (Michael O. Rabin). В настоящее время он наиболее широко используется как практичный и быстрый алгоритм проверки на простоту во встроенных библиотеках различных языков программирования и при генерации ключей криптографических систем.

Математический принцип

Алгоритм Миллера-Рабина, помимо малой теоремы Ферма, использует следующее свойство: «В поле вычетов по простому модулю ($\mathbb{Z}/p\mathbb{Z}$) решениями уравнения $x^2 \equiv 1 \pmod p$ могут быть только $x \equiv 1$ или $x \equiv -1$» (в случае составного модуля могут существовать и другие, нетривиальные квадратные корни).

Если из проверяемого нечетного числа $N$ вычесть $1$, то $N-1$ обязательно станет четным. Поэтому мы делим $N-1$ на $2$ столько раз, сколько возможно, и представляем в следующем виде:

$$ N-1 = d \cdot 2^s $$

(где $d$ — нечетное, $s \ge 1$)

Для любого основания $a$ ($1 < a < N-1$) мы проверяем, выполняется ли $a^{N-1} \equiv 1 \pmod N$ согласно малой теореме Ферма, но вычисляем это поэтапно. Конкретно, мы последовательно возводим в квадрат: $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$.

Условием для того, чтобы тест Миллера-Рабина определил $N$ как «простое (или с высокой вероятностью простое)», является выполнение любого из следующих утверждений:

$a^d \equiv 1 \pmod N$
Существует некоторое $r$ ($0 \le r < s$), такое что $a^{d \cdot 2^r} \equiv -1 \pmod N$.
- В C++ при вычислении по модулю $-1 \pmod N$ равно $N-1$.

Если $N$ простое, то для любого $a$ это условие обязательно выполняется. Напротив, если $N$ составное, математически доказано, что вероятность выполнения этого условия (вероятность обмана) при выборе случайного $a$ составляет не более $\frac{1}{4}$. Если провести $k$ независимых тестов, вероятность ошибочной оценки становится меньше или равна $\left(\frac{1}{4}\right)^k$, что на практике можно считать нулем. Не существует чисел, способных «абсолютно обмануть» алгоритм, подобных числам Кармайкла.

Поток алгоритма метода Миллера-Рабина (Блок-схема Mermaid)

Следующая схема показывает логический поток одного теста Миллера-Рабина (для одного основания $a$).

graph TD Start["Начало теста (Вход: N, a)"] --> CalcDS["Вычисление нечетного d и s, удовлетворяющих N-1 = d * 2^s"] CalcDS --> CalcX["Вычисление x = a^d mod N"] CalcX --> CheckX1{"x == 1 или x == N-1 ?"} CheckX1 -- "Да" --> ReturnTrue["Возможно простое (Probably Prime)"] CheckX1 -- "Нет" --> LoopStart["Начало цикла от r = 1 до s-1"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "Нет" --> ReturnFalse["Точно составное (Composite)"] LoopCondition -- "Да" --> SquareX["Вычисление x = (x * x) mod N"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Да" --> ReturnTrue CheckXMinus1 -- "Нет" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Да" --> ReturnFalse CheckXOne -- "Нет" --> LoopNext["Увеличение r на 1 и переход к следующему"] LoopNext --> LoopCondition

4. Детерминированная проверка для 64-битных целых чисел

Тест простоты Миллера-Рабина изначально является «вероятностным» алгоритмом, но если верхняя граница $N$ фиксирована, можно провести проверку со «100% достоверностью», протестировав все основания $a$ из определенного набора. Это называется Детерминированным тестом Миллера-Рабина (Deterministic Miller-Rabin Test).

Исследования Джима Синклера (Jim Sinclair) и других показали, что для всех целых чисел $N < 2^{64}$ (около $1.8 \times 10^{19}$) достаточно выбрать и проверить следующие $7$ простых чисел в качестве оснований $a$, чтобы получить полностью детерминированный результат.

Список оснований $a$ для проверки: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

Альтернативно, существует другой известный набор из $12$ простых чисел, с помощью которого также можно идеально проверить числа $N < 2^{64}$. {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

В этот раз, чтобы повысить простоту и надежность алгоритма, мы применим подход с использованием этих $12$ простых чисел (или более оптимизированных $7$ баз). В реализации на C++ мы применим оптимизацию, минимизирующую количество тестов путем разделения диапазонов с помощью условных переходов.

5. Высокоуровневая реализация на C++ (Highly Optimized C++ Implementation)

Теперь давайте объединим всю математическую теорию и дизайн алгоритма, чтобы представить реализацию функции проверки простоты Миллера-Рабина высочайшего уровня в современном C++.

Ключевые моменты реализации

Предотвращение переполнения при умножении 64-битных чисел: При $N \approx 10^{18}$ значение $x \times x$ при умножении по модулю может достигать $10^{36}$, что с легкостью переполнит максимальное значение обычных 64-битных целых чисел (uint64_t или long long), равное $1.8 \times 10^{19}$. Чтобы решить эту проблему, мы используем расширенный тип GCC или Clang __int128_t (или unsigned __int128) для выполнения вычислений с 128-битной точностью перед взятием модуля. Это позволяет быстро выполнять умножение по модулю без использования сложных алгоритмов.
Выбор детерминированных оснований: Когда значение $N$ невелико, мы оптимизируем алгоритм так, чтобы требовалось протестировать лишь небольшое число оснований (bases).

Полный исходный код на C++

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

 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
87
88
89
90
91
92
93
94
95
96


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// Быстрое вычисление (a * b) mod m с помощью 128-битного целого числа
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// Вычисление (base^exp) mod m методом бинарного возведения в степень
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// Детерминированная проверка 64-битных целых чисел тестом Миллера-Рабина
bool is_prime_miller_rabin(uint64_t n) {
 // Предварительная проверка граничных значений и малых простых чисел
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // Разложение на вид n-1 = d * 2^s
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // Список оснований (bases) для тестирования
 // Оптимизация для минимизации количества проверяемых оснований в зависимости от размера N
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 7 оснований, дающих детерминированный результат для всех чисел N < 2^64
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // Выполнение теста для каждого основания
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // Если a кратно n, определить невозможно, но n не простое

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // Первое условие выполнено, переход к следующему основанию

 bool composite = true;
 // Цикл s-1 раз (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // Второе условие выполнено, возможно простое
 break;
 }
 }

 // Если ни одно из условий не выполнено, число гарантированно составное
 if (composite) return false;
 }

 // Если все основания прошли проверку, число гарантированно простое
 return true;
}

int main() {
 // Примеры для тестирования
 vector<uint64_t> test_cases = {
 1000000007, // Известное простое число
 998244353, // Известное простое число
 1000000000000000003, // Простое число в районе 10^18
 1000000000000000007, // Составное число (10^18 + 7)
 561, // Число Кармайкла (составное)
 18446744073709551557ULL // Одно из наибольших простых чисел в районе 2^64
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

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

Рассмотрим производительность реализованного алгоритма.

Временная сложность (Time Complexity)

Метод пробных делений: $O(\sqrt{N})$
Тест Ферма: возведение в степень $O(\log N) \times k$ (где $k$ — количество попыток)
Метод Миллера-Рабина: возведение в степень и цикл $O(\log N) \times k$

В 64-битной среде ($N \le 2^{64}$) описанный выше детерминированный алгоритм Миллера-Рабина проверяет максимум $7$ оснований. Следовательно, $k \le 7$ можно считать константой, и общая временная сложность строго равна $O(\log N)$. Даже в максимальном случае ($N \approx 10^{19}$) количество шагов выполнения укладывается в $7 \times 64 = 448$ базовых операций, а время выполнения составляет менее нескольких микросекунд ($10^{-6}$ секунд). По сравнению с методом пробных делений $O(\sqrt{N})$ (около $4 \times 10^9$ итераций цикла), достигается ускорение в миллионы раз.

Дальнейшая оптимизация: Умножение Монтгомери (Montgomery Multiplication)

В реализации, приведенной в этой статье, используется расширенный 128-битный тип __int128_t для операции деления (вычисление остатка %). Даже на современных процессорах целочисленное деление (инструкция DIV) — это дорогостоящая операция, занимающая десятки тактов по сравнению со сложением или умножением.

Создатели библиотек и спортивные программисты, стремящиеся к экстремальной оптимизации, иногда применяют метод, называемый Умножением Монтгомери (Montgomery Multiplication). Умножение Монтгомери — это потрясающий алгоритм, который заменяет дорогостоящую операцию взятия модуля (деления) на «только битовые сдвиги и умножения» за счет отображения чисел в специальное «пространство Монтгомери». Интегрировав этот метод в модульное умножение при тесте Миллера-Рабина, можно увеличить скорость выполнения еще примерно в 2-3 раза. Поскольку это очень глубокая тема, мы подробно рассмотрим её в другой статье.

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

В этой статье мы охватили все аспекты проверки на простоту: от основ до продвинутых концепций. Давайте вспомним ключевые моменты.

Метод пробных делений надежен, но из-за вычислительной сложности $O(\sqrt{N})$ он теряет практичность при $N > 10^{12}$.
Тест Ферма очень быстр — $O(\log N)$, но имеет фатальный недостаток: он ошибается на абсолютно псевдопростых числах, таких как числа Кармайкла.
Тест простоты Миллера-Рабина — это практичный и мощнейший алгоритм, который устраняет слабость теста Ферма.
В реализации на C++ использование __int128_t позволяет безопасно обрабатывать переполнения при умножении 64-битных целых чисел.
В пределах 64-битных целых чисел ($N < 2^{64}$), выбирая $7$ или $12$ определенных простых чисел в качестве оснований, возможна детерминированная (со 100% точностью) проверка на простоту, а не вероятностная.

Быстрая проверка на простоту — это незаменимая технология при вычислениях с огромными числами. Предоставленный в этой статье исходный код алгоритма Миллера-Рабина на C++ достаточно надежен для использования в реальных задачах. Обязательно попробуйте применить его в своих проектах или на соревнованиях по алгоритмике!

graph LR TrialDivision["Метод пробных делений (O(√N))"] --> Fermat["Тест Ферма (O(log N), есть слабые места)"] Fermat --> MillerRabin["Метод Миллера-Рабина (O(log N), можно сделать детерминированным)"] MillerRabin --> Montgomery["+ Умножение Монтгомери (ускорение в несколько раз)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

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

Reference:

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

【Математическое объяснение】Как работает алгоритм 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, вероятно, будет продолжать удерживать трон как самый мощный алгоритм факторизации простых чисел.

Симуляция алгоритма Шора на Python

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

1. Введение: Кризис криптографии, вызванный квантовыми компьютерами

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

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

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

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

Почему факторизация так сложна? Даже при использовании «общего метода решета числового поля (General Number Field Sieve, GNFS)», известного как лучший алгоритм факторизации для классических компьютеров, его вычислительная сложность является субэкспоненциальной.

Временная сложность факторизации составного числа с количеством цифр $N$ с использованием классических методов выглядит следующим образом:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

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

Однако, если использовать алгоритм Шора на квантовом компьютере, вычислительная сложность радикально сокращается до полиномиального времени относительно количества битов входных данных $\log N$.

$$ O((\log N)^3) $$

Это означает, что при удвоении количества битов время вычислений на классическом компьютере возрастает астрономически, тогда как на квантовом компьютере оно увеличивается всего примерно в 8 раз. Это сведение класса сложности от экспоненциального времени к полиномиальному (включение в класс BQP) и есть истинное величие алгоритма Шора.

graph TD A["Увеличение размера входа (количества бит) N"] --> B{"Выбор алгоритма"} B -->|Классический: Общий метод решета числового поля| C["Субэкспоненциальный рост O(exp(...))"] B -->|Квантовый: Алгоритм Шора| D["Полиномиальное время O((log N)^3)"] C --> E["От тысяч до миллиардов лет (Невозможно взломать)"] D --> F["От нескольких минут до часов (Взлом за реалистичное время)"]

3. Общая картина алгоритма и математический фундамент

Алгоритм Шора на самом деле выполняется не полностью на квантовом компьютере. Он состоит из взаимодействия предварительной и последующей обработки на классическом компьютере и ключевой части (алгоритма нахождения периода) на квантовом компьютере.

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

graph TD A["Вход: Составное число N для факторизации"] --> B["Выбор случайного числа a, где a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Да" --> D["Вывод тривиального делителя gcd(a, N) и завершение"] C -- "Нет" --> E["Нахождение периода r функции f(x) = a^x mod N квантовым алгоритмом"] E --> F{"r четное и a^(r/2) ≢ -1 mod N ?"} F -- "Нет" --> B F -- "Да" --> G["Вычисление делителей p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Выход: p, q"]

Сведение от факторизации к проблеме нахождения периода

Гениальное озарение Шора заключалось в преобразовании «проблемы факторизации» в «проблему нахождения порядка (Order Finding Problem)».

Рассмотрим целое число $N$ (число, которое нужно факторизовать) и взаимно простое с ним целое число $a$ ($1 < a < N$). Определим следующую модулярную экспоненциальную функцию:

$$ f(x) = a^x \bmod N $$

Эта функция имеет некоторый период $r$. То есть для любого $x$ выполняется $f(x+r) = f(x)$. В частности, при $x=0$:

$$ a^r \equiv 1 \pmod N $$

Минимальное положительное целое число $r$, при котором это выполняется, называется «порядком (Order) $a$ по модулю $N$». Если мы сможем найти этот период $r$, то сможем вывести простые множители следующим образом.

Преобразовав уравнение, получим:

$$ a^r - 1 \equiv 0 \pmod N $$

Если $r$ четное, мы можем разложить его на множители, используя формулу разности квадратов:

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Это означает, что $N$ имеет общий делитель либо с $(a^{r/2} - 1)$, либо с $(a^{r/2} + 1)$ (однако должно выполняться условие $a^{r/2} \not\equiv -1 \pmod N$). Следовательно, используя алгоритм Евклида:

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

Вычислив это, мы можем найти нетривиальные простые множители $p, q$ числа $N$. Эти вычисления (нахождение наибольшего общего делителя и генерация случайных чисел) выполняются очень быстро на классическом компьютере. Проблема сводится к тому, как быстро найти период $r$. На классическом компьютере поиск самого этого периода $r$ занимает экспоненциальное время. И здесь на сцену выходит квантовый компьютер.

4. Часть квантового алгоритма: Механизм нахождения периода

Подпрограмма для нахождения периода $r$ с использованием квантового компьютера состоит из следующих 4 шагов:

graph LR subgraph "Переходы квантовых состояний" S1["|0⟩|0⟩ (Инициализация)"] --> S2["Вентиль H: Суперпозиция Σ|x⟩|0⟩"] S2 --> S3["Оракул U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Извлечение периода через интерференцию"] S4 --> S5["Измерение: Получение приближенного значения y"] end

Шаг 1: Инициализация квантового регистра и суперпозиция

Сначала мы подготавливаем два квантовых регистра. Первый регистр предназначен для ввода состояния, а второй — для сохранения результата вычислений функции. Начальное состояние полностью равно $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Применив вентиль Адамара (Hadamard Gate) ко всем кубитам первого регистра, мы создаем состояние равновероятной суперпозиции всех возможных входов $x$ (от $0$ до $Q-1$, где $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Благодаря этому квантовый компьютер одновременно сохраняет состояния для всех $Q$ входов за одну операцию. Это является мощным источником квантового параллелизма.

Шаг 2: Применение функции-оракула (модульное возведение в степень)

Далее, используя квантовую схему $U_f$, мы вычисляем функцию $f(x) = a^x \bmod N$ и сохраняем ее результат во втором регистре.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

На этом этапе первый и второй регистры находятся в состоянии квантовой запутанности (энтанглмента). Если бы мы (гипотетически) измерили второй регистр и получили определенное значение $k = a^{x_0} \bmod N$, состояние первого регистра коллапсировало бы в суперпозицию тех $x$, которые дают это значение $k$. Поскольку период функции равен $r$, оставшиеся состояния будут иметь значения с шагом $r$: $x_0, x_0+r, x_0+2r, \dots$

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Однако мы хотим узнать не $x_0$, а сам период $r$. Напрямую измерить $r$ из этого состояния невозможно. Поэтому мы используем квантовое преобразование Фурье.

Шаг 3: Фазовая интерференция через Квантовое преобразование Фурье (QFT)

Мы применяем Квантовое преобразование Фурье (Quantum Fourier Transform, QFT) к первому регистру. QFT — это квантовая версия классического дискретного преобразования Фурье, которая преобразует амплитуды вектора состояния. Действие QFT на базисное состояние $|x\rangle$ определяется следующим образом:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Где $\omega = e^{2\pi i / Q}$.

Применение QFT вызывает интерференцию амплитуд состояний. Опуская математические подробности: если применить QFT к состоянию с периодом $r$, волны будут создавать конструктивную интерференцию (Constructive Interference) только тогда, когда $y$ очень близко к кратному $Q/r$. Для всех остальных состояний из-за деструктивной интерференции (Destructive Interference) амплитуды вероятностей взаимно уничтожаются, приближаясь к нулю.

Шаг 4: Измерение и разложение в непрерывную дробь

Наконец, мы измеряем первый регистр. Полученное при измерении значение $y$ с высокой вероятностью удовлетворяет следующему условию:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

(Где $c$ — неизвестное целое число $0 \le c < r$)

Применив классический алгоритм разложения в непрерывную дробь (Continued Fraction Expansion) к полученному рациональному числу $y/Q$, мы вычисляем подходящую дробь $c/r$ и извлекаем период $r$ из ее знаменателя.

5. Реализация симуляции с использованием Python и Qiskit

Поскольку одна лишь теория не дает полного представления, давайте попробуем смоделировать алгоритм Шора на практике, используя Python и фреймворк квантовых вычислений от IBM — Qiskit.

Здесь мы реализуем самый классический и известный пример: «факторизация $N=15$ с использованием $a=7$».

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

Пожалуйста, заранее установите Qiskit.

1

pip install qiskit qiskit-aer numpy

Полный код реализации на Python

Следующий код является примером реализации алгоритма Шора, адаптированного для $N=15, a=7$. Поскольку построение универсальной модульной экспоненциальной схемы требует слишком высоких вычислительных затрат на текущих симуляторах, операции вентилей для конкретного случая $a=7$ здесь жестко закодированы.

 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
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Функция для построения обратного квантового преобразования Фурье (QFT†)
def qft_dagger(n):
 """Генерация схемы обратного квантового преобразования Фурье для n кубитов"""
 qc = QuantumCircuit(n)
 # Вентили SWAP для обращения порядка
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Применение управляемых фазовых вентилей и вентиля H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Функция для построения управляемой модульной экспоненциальной операции 7^x mod 15
def c_amod15(a, power):
 """Генерация управляемого вентиля U для конкретного a и степени (только для N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Жестко закодированная логика 7^x mod 15 для случая a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Построение основной квантовой схемы
def shor_circuit(a, n_count):
 # n_count: Количество битов управляющего регистра
 # Целевой регистр использует 4 бита для представления чисел от 0 до 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Инициализация первого регистра (управляющего регистра) (создание суперпозиции)
 for q in range(n_count):
 qc.h(q)

 # Инициализация второго регистра (целевого регистра) в |1> (0001)
 qc.x(3 + n_count)

 # Применение управляемой модульной экспоненциальной операции (оракула)
 for q in range(n_count):
 # Применение операции в степени 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Применение обратного квантового преобразования Фурье к первому регистру
 qc.append(qft_dagger(n_count), range(n_count))

 # Измерение первого регистра
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Секция выполнения ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Использование 8 кубитов для управляющего регистра (Q=256)

 print(f"Настройки поиска: N={N}, a={a}, количество управляющих кубитов={n_count}")

 # Генерация схемы
 qc = shor_circuit(a, n_count)

 # Выполнение в симуляторе
 sim = AerSimulator()
 # В новых версиях Qiskit рекомендуется использовать transpile
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nРезультаты измерений (битовая строка: количество наблюдений):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} раз")

 # Классическая постобработка: Определение периода r с помощью разложения в непрерывную дробь
 print("\n--- Вычисление периода и факторизация ---")
 phases = []
 for output in counts:
 # Преобразование битовой строки в десятичное число
 decimal = int(output, 2)
 # Фаза = Измеренное значение / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Получение подходящей дроби через разложение в непрерывную дробь. Верхний предел знаменателя - N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Измеренное значение: {decimal:3d} | Фаза: {phase:.4f} | Непрерывная дробь: {frac} | Оценочный период r = {r}")

 # Проверка, является ли период r четным и дает ли он действительный результат
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Успех! Простые множители {N} - это {guess1} и {guess2}.")
 else:
 print(f" => Только тривиальные множители. Повторить.")
 else:
 print(f" => Неудача, так как период нечетный.")

Объяснение кода и анализ результатов выполнения

При выполнении приведенного выше кода в качестве результатов измерения управляющего регистра с высокой вероятностью будут получены определенные пики (наблюдаемые значения). При n_count=8 ($Q=256$) на идеальном квантовом компьютере (или симуляторе) такие значения, как 0, 64, 128, 192, появятся с подавляющей вероятностью.

Если разделить их на $Q=256$, то фаза $y/Q$ будет соответственно $0.0$, $0.25$, $0.5$, $0.75$. Если разложить эту фазу в непрерывную дробь:

$0.25 \to 1/4$ (Оценочный период $r=4$)
$0.50 \to 1/2$ (Оценочный период $r=2$)
$0.75 \to 3/4$ (Оценочный период $r=4$)

Используя полученный период $r=4$, мы вычисляем простые множители. Поскольку $a=7, r=4$: $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Мы успешно выполнили факторизацию $15 = 3 \times 5$.

[!TIP] Если получено измеренное значение $y=128$ (фаза $0.5$), знаменатель будет $2$, и мы получим делитель периода, а не истинный период $r=4$. В таких случаях можно найти истинный период, выполнив алгоритм несколько раз или проверив кратные полученного $r$.

6. Проблемы практического применения и ограничения эпохи NISQ

Хотя на симуляторе легко факторизовать $N=15$, для факторизации RSA-2048 (617-значное десятичное число), используемого в реальном мире, перед реальными квантовыми компьютерами всё ещё стоит множество барьеров.

Эпоха, в которой мы живем сейчас, называется эпохой NISQ (Noisy Intermediate-Scale Quantum: шумные квантовые устройства промежуточного масштаба). Кубиты крайне уязвимы к шуму из внешней среды, и в процессе вычислений происходит «декогеренция», разрушающая их состояние.

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

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

[!WARNING] Однако существует модель угрозы «Store Now, Decrypt Later (Сохранить сейчас, расшифровать позже)». Злоумышленники могут использовать стратегию массового сохранения текущих зашифрованных конфиденциальных коммуникаций в виде зашифрованных данных, чтобы полностью расшифровать их в тот самый момент, когда через 10–20 лет появятся мощные квантовые компьютеры.

7. Переход к постквантовой криптографии (PQC)

В преддверии такого «Q-Day» (дня, когда квантовые компьютеры взломают шифрование), криптографы по всему миру во главе с Национальным институтом стандартов и технологий США (NIST) работают над стандартизацией постквантовой криптографии (Post-Quantum Cryptography, PQC).

PQC основывается на новых математических проблемах (например, проблемы на решетках, многомерные полиномиальные проблемы, алгоритмы на основе хеш-функций), которые, как считается математически, не могут быть эффективно решены даже с помощью алгоритма Шора (или алгоритма Гровера). Такие алгоритмы, как «CRYSTALS-Kyber» и «CRYSTALS-Dilithium», уже выбраны в качестве стандартов, и постепенно начинается их внедрение в iMessage от Apple и коммуникационные протоколы различных веб-браузеров.

Для инженеров, управляющих ИТ-инфраструктурой, одной из главных задач в будущем станет внедрение в системы «криптографической гибкости (crypto-agility: возможности быстрого переключения методов шифрования)» для перехода от существующего RSA и криптографии на эллиптических кривых к PQC.

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

В этой статье мы провели исчерпывающее объяснение объемом в 10 тысяч символов: начиная с теоретического математического фундамента алгоритма Шора, механизма извлечения периода с использованием квантового преобразования Фурье, и заканчивая конкретным кодом симуляции на Python и Qiskit.

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

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

Источники и литература

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【Иллюстрированное руководство по 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

День, когда квантовые компьютеры станут практичными: текущее состояние в 2026 году

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

1. Введение: Насколько продвинулись квантовые компьютеры к 2026 году

По состоянию на 2026 год квантовые вычисления совершили решающий переход от “теоретической мечты” к “инженерной реальности”. По мере того, как ограничения устройств NISQ (Noisy Intermediate-Scale Quantum), которые были мейнстримом еще несколько лет назад, стали очевидны, исследовательские институты и технологические гиганты по всему миру взяли курс на реализацию “отказоустойчивых квантовых вычислений (FTQC: Fault-Tolerant Quantum Computing)”.

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

2. Основы квантовых состояний и точность (Fidelity)

Кубит (Qubit), базовая единица квантового компьютера, в отличие от классического бита (0 или 1), может находиться в состоянии суперпозиции 0 и 1 (Superposition). Состояние одиночного кубита представляется в виде вектора в гильбертовом пространстве следующим образом:

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Где $\alpha$ и $\beta$ — комплексные амплитуды вероятности, удовлетворяющие следующему условию нормировки:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Чрезвычайно важным показателем при оценке производительности квантовых вычислений является точность (Fidelity). Точность $F$ между идеальным квантовым состоянием $|\psi\rangle$ и фактической матрицей плотности $\rho$, которая деградировала из-за шума и стала смешанным состоянием, определяется следующим образом:

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

В 2026 году точность двухкубитных вентилей (например, вентилей CNOT и CZ) в сверхпроводящих системах стала стабильно превышать барьер в 99,99% (так называемые “четыре девятки”). Это значение значительно превышает порог коррекции ошибок поверхностного кода (около 99%) и является одним из крупнейших прорывов на пути к практическому применению.

3. Пределы эры NISQ и смена парадигмы к FTQC

Период со второй половины 2010-х до первой половины 2020-х годов был эрой NISQ (Noisy Intermediate-Scale Quantum) — устройств от нескольких десятков до сотен кубитов без коррекции ошибок. Однако у NISQ были четкие ограничения.

По мере увеличения глубины схемы (Depth) ошибки накапливаются экспоненциально, что делает невозможным получение значимых результатов вычислений. Общая вероятность успеха $P_{success}$ при глубине схемы $D$ затухает относительно точности одиночного вентиля $f$ и количества вентилей $N$ следующим образом:

$$ P_{success} \approx f^N $$

Если $f = 0.99$ и применяется 1000 вентилей, то $0.99^{1000} \approx 4.3 \times 10^{-5}$, и результат почти полностью теряется в случайном шуме. По этой причине в 2026 году ресурсы сосредоточены на создании логических кубитов (Logical Qubit), а не на прямом масштабировании алгоритмов NISQ (таких как VQE или QAOA).

4. Квантовая коррекция ошибок и логические кубиты: передовая линия поверхностного кода

Квантовая коррекция ошибок (QEC: Quantum Error Correction) — это технология, которая кодирует несколько “физических кубитов” для создания одного “логического кубита”, обнаруживая и исправляя ошибки. В настоящее время наиболее перспективным считается поверхностный код (Surface Code).

4.1 Структура поверхностного кода (Surface Code)

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

graph TD A["Кубит данных (D1)"] --- B["Кубит измерения (M1)"] B --- C["Кубит данных (D2)"] C --- D["Кубит измерения (M2)"] D --- E["Кубит данных (D3)"] B --- F["Кубит данных (D4)"] D --- G["Кубит данных (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Используя операторы стабилизатора $S_x$ и $S_z$, постоянно отслеживаются перевороты битов (X-ошибки) и перевороты фазы (Z-ошибки).

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

Важным достижением 2026 года стало полное преодоление “точки безубыточности (Break-even point)”. Иными словами, шум, устраняемый коррекцией ошибок, стал больше, чем шум, вызываемый дополнительными схемами коррекции, и срок жизни логических кубитов стал на несколько порядков превышать срок жизни физических кубитов.

4.2 Цикл квантовой коррекции ошибок

Коррекция ошибок работает как непрерывный цикл обратной связи.

sequenceDiagram participant D as "Кубиты данных" participant M as "Вспомогательные/Измерительные кубиты" participant C as "Классический контроллер" loop "Цикл извлечения синдрома (около 1 микросекунды)" D->>M: "Запутывание (CNOT/CZ)" M->>C: "Измерение состояния (Синдром)" C->>C: "Декодирование синдрома (например, Minimum Weight Perfect Matching)" C-->>D: "Применение коррекции Паули (при необходимости)" end

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

5. Эволюция аппаратной архитектуры (Версия 2026 года)

В 2026 году квантовое аппаратное обеспечение развивается в основном по трем направлениям: “сверхпроводящие системы”, “ионные ловушки” и “топологические системы”.

5.1 Интеграция сверхпроводящих кубитов

Сверхпроводящие системы — область, в которой лидируют IBM и Google; в ней доминируют трансмонные (Transmon) кубиты, использующие джозефсоновские переходы. К 2026 году были созданы мегачипы, интегрирующие от нескольких тысяч до десяти тысяч физических кубитов на одном кристалле.

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

5.2 Двумерное масштабирование ионных ловушек и оптические межсоединения

Системы ионных ловушек (возглавляемые Quantinuum, IonQ и др.) используют внутренние энергетические состояния ионов, левитирующих в вакууме, в качестве кубитов. По сравнению со сверхпроводящими системами их преимущество заключается в чрезвычайно длительном времени когерентности T1/T2 и возможности связи “каждый с каждым” (All-to-All Connectivity).

Прорывом 2026 года стал переход архитектуры QCCD (Quantum Charge Coupled Device) в двумерный формат и высокоскоростная генерация запутанности между несколькими ловушками с использованием фотонных межсоединений. Это кардинально улучшило “низкую скорость вентилей” и “масштабируемость”, которые были слабыми местами ионных ловушек.

5.3 Топологические квантовые вычисления: контроль энионов

Топологические квантовые вычисления, долгое время считавшиеся теоретическими, в 2026 году наконец перешли на стадию экспериментальной проверки. Этот метод, продвигаемый Microsoft и другими, использует неабелевы энионы (Non-Abelian Anyons), называемые “нулевыми модами Майораны (Majorana Zero Modes)”.

Квантовые вентили выполняются с помощью операции “плетения (Braiding)”, которая меняет местами позиции энионных частиц.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Где $B_{ij}$ — оператор плетения. Топологический подход по своей сути устойчив к шуму окружающей среды (аппаратный уровень отказоустойчивости), поскольку хранение информации зависит от топологии всего “узла”, а не от локального состояния частиц. В 2026 году впервые в мире было подтверждено создание топологических логических кубитов с высокой точностью, что привлекло внимание как мощный короткий путь к FTQC.

6. Дорожная карта и перспективы практического применения

Чтобы квантовые компьютеры могли по-настоящему продемонстрировать квантовое превосходство (Quantum Advantage), превосходя классические компьютеры (суперкомпьютеры) в таких областях, как “вычислительная химия”, “материаловедение” и “финансовое моделирование”, требуются тысячи логических кубитов.

gantt title "Дорожная карта квантовых вычислений (пересмотрена в 2026 году)" dateFormat YYYY axisFormat %Y section "Эра NISQ" "Шумные кубиты (<1000)" :done, 2018, 2024 section "Ранний FTQC" "Демонстрация точки безубыточности" :done, 2024, 2026 "Сотни логических кубитов" :active, 2026, 2028 section "Полномасштабный FTQC" "1000+ логических кубитов (Коммерческое применение)" : 2028, 2030 "Универсальный отказоустойчивый квантовый компьютер" : 2030, 2035

6.1 Текущие проблемы и будущее

Крупнейшими проблемами по состоянию на 2026 год являются охлаждающая способность гигантских криостатов (рефрижераторов растворения) для поддержания сверхнизких температур, а также проводка (узкое место ввода/вывода), соединяющая устройства управления при комнатной температуре и криогенные квантовые чипы. В ответ на это ускоренными темпами разрабатываются чипы контроллеров CMOS (Cryo-CMOS), работающие в криогенных условиях.

Заключение

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

Эта статья написана на основе новейших исследовательских работ и отраслевых тенденций в области квантовых вычислений по состоянию на 2026 год.