Prime Numbers on kenji.blog

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

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 — это прекрасный учебный материал, который демонстрирует глубину и красоту математики. Мы надеемся, что благодаря этой статье вы смогли хотя бы немного почувствовать, насколько интересными могут быть криптография и математика.