Prime Numbers on kenji.blog

A Hipótese de Riemann e a Distribuição dos Números Primos: A Profunda Relação com a Criptografia Moderna

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

1. Introdução: O Mistério Cósmico dos Números Primos e a Hipótese de Riemann

Os “Números Primos” (Prime Numbers) são números naturais divisíveis apenas por 1 e por si mesmos, sendo frequentemente chamados de “átomos” do mundo da matemática. Essa sequência que segue como 2, 3, 5, 7, 11, 13… parece, à primeira vista, desordenada e aleatória. Desde que o matemático grego antigo Euclides provou que “os números primos são infinitos”, incontáveis matemáticos têm tentado desvendar os padrões ocultos nessa disposição de primos.

Aquele que chegou mais perto de desvendar esse mistério dos números primos foi o matemático alemão Bernhard Riemann, que propôs a “Hipótese de Riemann” (Riemann Hypothesis) em 1859. A Hipótese de Riemann é um dos problemas mais importantes e não resolvidos da matemática moderna, com um prêmio de 1 milhão de dólares oferecido pelo Instituto de Matemática Clay como um dos Problemas do Prêmio Millennium.

À primeira vista, pode parecer que esse problema formidável da matemática pura sobre a distribuição de números primos não tenha relação com o nosso dia a dia. No entanto, a segurança da internet, que sustenta a infraestrutura da sociedade moderna, especialmente as tecnologias de criptografia modernas como a criptografia RSA e a criptografia de curva elíptica (ECC), depende profundamente das propriedades de números primos gigantescos.

Neste artigo, faremos uma jornada matemática partindo da distribuição dos números primos até o Teorema dos Números Primos, a função zeta de Riemann e o núcleo da Hipótese de Riemann, explorando de forma extremamente detalhada e profunda como isso se conecta com a criptografia moderna e o que aconteceria com o mundo se a Hipótese de Riemann fosse provada.

2. O Teorema dos Números Primos e a Distribuição de Primos: A Descoberta de Gauss

Para entender como os números primos estão distribuídos, os matemáticos conceberam a função de contagem de números primos (Prime-counting function) $\pi(x)$, que representa “quantos números primos existem menores ou iguais a um dado número $x$”.

Por exemplo:

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

O gênio matemático de 15 anos, Carl Friedrich Gauss, calculou extensas tabelas de números primos e descobriu que a frequência de aparecimento dos números primos diminui de forma inversamente proporcional ao logaritmo natural $\ln x$. Em outras palavras, ele conjecturou que a probabilidade de encontrar um número primo perto de um número $x$ é de aproximadamente $\frac{1}{\ln x}$.

Expressando isso por meio de uma integral, obtemos o logaritmo integral (Logarithmic integral) $\text{Li}(x)$.

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

A conjectura de Gauss foi posteriormente provada de forma independente por Jacques Hadamard e Charles Jean de la Vallée Poussin em 1896, estabelecendo-se como o Teorema dos Números Primos (Prime Number Theorem, PNT).

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

Ou, de forma aproximada, pode ser expresso como:

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

Este teorema mostrou que, de uma perspectiva macroscópica, os números primos têm uma distribuição muito suave e previsível. No entanto, microscopicamente, sempre existe um “erro”, ou seja, uma “flutuação” entre $\pi(x)$ e $\text{Li}(x)$. A verdadeira natureza dessa flutuação é exatamente o maior mistério que a Hipótese de Riemann tenta desvendar.

3. A Função Zeta de Riemann e o Produto de Euler

A arma mais poderosa para analisar a distribuição dos números primos é a Função Zeta de Riemann (Riemann Zeta Function). Originalmente, era uma série infinita definida por Leonhard Euler para números reais $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 $$

Uma das maiores conquistas de Euler foi provar que esta série infinita pode ser expressa como um produto infinito sobre todos os números primos $p$. Este é o Produto de Euler (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 $$

Uma compreensão intuitiva da prova é que, se expandirmos cada termo do lado direito como uma série geométrica e os multiplicarmos, o Teorema Fundamental da Aritmética (que afirma que todo número natural pode ser expresso de forma única como um produto de primos) reconstrói perfeitamente a soma dos recíprocos dos números naturais no lado esquerdo.

Essa única equação se tornou a ponte que liga a análise (séries infinitas, funções contínuas) à teoria dos números (números primos, números discretos). Estudar a função zeta é sinônimo de estudar a distribuição dos números primos.

4. Continuação Analítica e a Extensão para o Plano Complexo

A genialidade de Riemann reside no fato de ele ter estendido a variável $s$ de $\zeta(s)$, que Euler considerava apenas para números reais, para números complexos $s = \sigma + it$ ($\sigma$ é a parte real e $t$ é a parte imaginária).

A série infinita original converge apenas para $\sigma > 1$, mas Riemann usou um método chamado “Continuação Analítica (Analytic Continuation)” para estender a definição de modo que $\zeta(s)$ fizesse sentido em todo o plano complexo, com exceção do polo em $s = 1$.

Ele também derivou uma bela equação funcional (Functional equation) que a função zeta satisfaz.

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

Aqui, $\Gamma(x)$ é a função gama. Com esta equação, podemos conhecer as propriedades do semiplano esquerdo a partir das propriedades do semiplano direito.

Zeros (Zeros of the Zeta Function)

Os números complexos $s$ para os quais o valor da função zeta se torna 0 são chamados de “zeros”. A partir da equação funcional, quando $s$ é um número par negativo ($-2, -4, -6, \dots$), $\sin(\pi s / 2)$ torna-se 0, resultando em $\zeta(s) = 0$. Estes são chamados de zeros triviais (Trivial zeros).

No entanto, o que importa para a distribuição dos números primos são os outros zeros, ou seja, os zeros não triviais (Non-trivial zeros), que existem na “faixa crítica (Critical strip)” onde $0 \le \sigma \le 1$.

5. O Núcleo da Hipótese de Riemann e a Fórmula Explícita

Riemann calculou alguns zeros e formulou uma conjectura surpreendente. Esta é a Hipótese de Riemann.

Hipótese de Riemann (Riemann Hypothesis) Todos os zeros não triviais da função zeta de Riemann $\zeta(s)$ encontram-se na linha reta onde a parte real é igual a $1/2$ ($\text{Re}(s) = 1/2$).

Esta reta onde a parte real é 1/2 é chamada de “linha crítica (Critical line)”.

graph TD A["Função Zeta de Riemann ζ(s)"] --> B["Extensão para o plano complexo via continuação analítica"] B --> C["Zeros triviais (s = -2, -4, -6 ...)"] B --> D["Zeros não triviais (0 <= Re(s) <= 1)"] D --> E["Hipótese de Riemann"] E --> F["Todos os zeros não triviais estão em Re(s) = 1/2"] F --> G["Para a prova do limite do termo de erro da distribuição de primos"]

Por que a Hipótese de Riemann é tão importante? Porque os zeros da função zeta determinam completamente a distribuição dos números primos.

Riemann e o matemático posterior von Mangoldt derivaram a “Fórmula Explícita (Explicit formula)”, que descreve com precisão a distribuição dos números primos. Usando a função de Chebyshev $\psi(x)$, ela pode ser expressa da seguinte forma:

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

Aqui, a soma é sobre todos os zeros não triviais $\rho$ da função zeta. O termo principal é $x$ (o que corresponde ao Teorema dos Números Primos), e ao adicionar e subtrair termos ondulatórios que dependem dos zeros $\rho$, a distribuição exata em forma de degraus dos números primos é restaurada. Pode-se dizer que os zeros não triviais representam as “frequências (ondas)” da distribuição dos números primos.

Se a Hipótese de Riemann estiver correta e a parte real de todos os zeros não triviais $\rho$ for exatamente $1/2$, o termo de erro do Teorema dos Números Primos ficará dentro da menor margem teoricamente possível.

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

Em outras palavras, se a Hipótese de Riemann for verdadeira, fica provado que os números primos estão distribuídos da forma mais “ordenada e bela” que possamos imaginar.

6. A Relação Inseparável entre a Criptografia Moderna e os Números Primos

Até aqui estivemos no mundo profundo da matemática pura, mas essas propriedades dos números primos sustentam fundamentalmente a sociedade digital moderna. O exemplo mais representativo são os sistemas de criptografia de chave pública, como a criptografia RSA.

A segurança de todas as comunicações, como pagamentos com cartão de crédito na internet, transmissão de senhas e assinaturas digitais em blockchain, depende dos “números primos”.

Como funciona a Criptografia RSA

A segurança da criptografia RSA é baseada no fato matemático (o problema de fatoração de inteiros) de que “a fatoração de um número composto com muitos dígitos é extremamente difícil”.

Geração de Chaves: Escolhem-se aleatoriamente dois números primos gigantescos $p$ e $q$ (por exemplo, de 2048 bits cada). Multiplicam-se ambos para calcular $N = p \times q$. Este $N$ se torna parte da chave pública. Usando a função totiente de Euler $\phi(N) = (p-1)(q-1)$, gera-se a chave privada $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Criptografia e Descriptografia: O texto plano (plaintext) $M$ é convertido em um texto cifrado (ciphertext) $C$ usando a chave pública $e, N$.
$$ C \equiv M^e \pmod{N} $$
Apenas aquele que possui a chave privada $d$ pode descriptografar.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Texto plano (Plaintext)"] --> B["Criptografado com a chave pública (e, N)"] B --> C["Texto cifrado (Ciphertext)"] C --> D["Descriptografado com a chave privada (d)"] D --> E["Texto plano original"] F["Atacante (Attacker)"] -- "Tenta fatorar N" --> C F -.-> G["Sem saber p e q, d é incalculável"]

Para quebrar a criptografia RSA, é necessário encontrar os números primos originais $p$ e $q$ a partir do gigantesco $N$ (fatoração de primos). Mesmo usando os algoritmos predominantes atuais (como o Crivo do Corpo de Números Generalizado: GNFS), diz-se que fatorar um número de centenas de dígitos levaria um tempo que excede muito a idade do universo, mesmo utilizando supercomputadores.

7. O Impacto da Hipótese de Riemann na Criptografia

Então, como a “Hipótese de Riemann”, que está no ápice da matemática pura, cruza-se com a “criptografia”?

7.1. Algoritmos de Geração de Números Primos (Teste de Primalidade) e a Hipótese Generalizada de Riemann (GRH)

Para operar a criptografia RSA, primeiro é necessário gerar os gigantescos números primos $p$ e $q$. No entanto, determinar de forma confiável e rápida “se um determinado número é primo” não é algo simples.

Atualmente, o que é utilizado de forma prática é um algoritmo probabilístico chamado teste de primalidade de Miller-Rabin (Miller-Rabin primality test). Esse algoritmo é rápido, mas carrega o risco de classificar incorretamente, com uma probabilidade extremamente baixa, um número composto como primo, um chamado “pseudoprimo”.

No entanto, assumindo que a “Hipótese Generalizada de Riemann (Generalized Riemann Hypothesis, GRH)”, que estende a Hipótese de Riemann às funções L de Dirichlet, é verdadeira, a história muda drasticamente.

Se a GRH for verdadeira, o limite superior do número de testes no teste de Miller-Rabin será matematicamente garantido, elevando-o de um algoritmo probabilístico para um “algoritmo de tempo polinomial determinístico” (este era um fato crucial já conhecido antes da descoberta do teste de primalidade AKS).

Em outras palavras, a Hipótese de Riemann (e sua generalização) desempenha o papel de dar uma garantia direta para a base da criptografia: “é possível gerar números primos gigantescos de forma rápida e com absoluta confiança?”.

7.2. Relação com os Algoritmos de Fatoração

Ao avaliar a complexidade computacional dos algoritmos usados para decifrar códigos (como o Crivo do Corpo de Números Generalizado), o conhecimento sobre a distribuição dos números primos também é indispensável. A maioria dos algoritmos de fatoração depende da distribuição de “números lisos (Smooth numbers: números que possuem apenas pequenos fatores primos)”.

Para avaliar rigorosamente a frequência com que números lisos aparecem, é necessária uma profunda compreensão da distribuição dos números primos, e aqui também são plenamente utilizadas técnicas de teoria analítica dos números que se conectam diretamente à função zeta e à Hipótese de Riemann. Se a Hipótese de Riemann for provada e o erro na distribuição de primos for completamente determinado, será possível discernir os limites de desempenho dos algoritmos de fatoração de forma mais precisa.

8. Se a Hipótese de Riemann for Provada, a Criptografia será Quebrada?

Assim como uma lenda urbana, às vezes se diz que “se a Hipótese de Riemann for resolvida, a criptografia RSA desmoronará em um instante”, mas isso é matematicamente impreciso.

A prova da Hipótese de Riemann, por si só, não produzirá imediatamente um algoritmo mágico que acelera drasticamente a fatoração. Isso porque a Hipótese de Riemann é, em última análise, um teorema sobre os “padrões de distribuição macroscópicos” dos números primos, e não nos diz diretamente por quais números primos um número específico $N$ é divisível (uma propriedade local).

No entanto, o impacto não é zero. Isso porque é extremamente provável que, no processo de provar a Hipótese de Riemann, “novas ferramentas matemáticas” e “métodos analíticos desconhecidos” sejam descobertos. Olhando para a história, quando o Último Teorema de Fermat ou a Conjectura de Poincaré foram provados, as novas teorias desenvolvidas no processo impulsionaram significativamente a matemática como um todo.

Se for estabelecido um método desconhecido de geometria algébrica ou de geometria não-comutativa capaz de manipular completamente as propriedades dos zeros da função zeta de Riemann, não se pode negar a possibilidade de que isso leve à descoberta de um algoritmo de fatoração revolucionário (por exemplo, um algoritmo clássico que reduz a complexidade para o tempo polinomial). Nesse sentido, os criptógrafos nunca podem tirar os olhos dos desenvolvimentos da Hipótese de Riemann.

Computadores Quânticos e o Algoritmo de Shor

Uma ameaça mais direta e realista à criptografia não é a prova da Hipótese de Riemann, mas os computadores quânticos. O “Algoritmo de Shor”, anunciado por Peter Shor em 1994, provou que, com um computador quântico de capacidade suficiente, a fatoração pode ser resolvida em tempo polinomial. Isso fundamentalmente quebraria a criptografia RSA e a criptografia de curva elíptica.

Atualmente, ao redor do mundo, há uma transição em andamento para a “Criptografia Pós-Quântica (Post-Quantum Cryptography, PQC)” (como a criptografia baseada em reticulados), que não pode ser decifrada nem por computadores quânticos. As tecnologias de criptografia baseadas em números primos podem, de certa forma, estar encerrando sua era de ouro, mas o valor matemático dos números primos em si nunca se perderá.

9. Conclusão: O Cruzamento entre a Abstração da Matemática e o Mundo Real

graph TD A["Exploração da matemática pura"] --> B["Esclarecimento da Hipótese de Riemann"] B --> C["Compreensão completa da distribuição de números primos"] C --> D["Avanço rápido na teoria dos números e geometria algébrica"] D -.-> E["Possibilidade de novos algoritmos de fatoração"] E -.-> F["Atualização na avaliação de segurança da criptografia"] A --> G["Matemática aplicada e ciência da computação"] G --> H["Eficiência no teste de primalidade e geração de códigos"] H --> F

A exploração insaciável dos números primos, que remonta à Grécia Antiga, foi sublimada por um gênio chamado Riemann em uma bela sinfonia no plano complexo (os zeros da função zeta). E, surpreendentemente, esse cristal de matemática pura e inocente foi aplicado séculos depois como o escudo mais forte para garantir a segurança da sociedade da internet.

A Hipótese de Riemann é uma entidade que simboliza, simultaneamente, a “beleza abstrata” e a “incrível aplicabilidade ao mundo físico e à sociedade real” que a matemática possui.

Quando esta montanha colossal da matemática, cujo cume ninguém ainda alcançou, for um dia conquistada, compreenderemos completamente a verdade cósmica dos números primos, e também ganharemos uma nova perspectiva sobre os alicerces da sociedade da informação. Estudar criptografia é, por si só, uma jornada pela história da sabedoria humana.

Implementando um Algoritmo Rápido de Teste de Primalidade em C++ (Miller-Rabin, etc.)

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

Introdução: Por que é necessário um teste de primalidade rápido?

No mundo da ciência da computação, teoria da criptografia e programação competitiva, determinar de forma rápida e precisa “se um determinado número é primo” é um problema fundamental e extremamente importante. Por exemplo, a criptografia de chave pública, como a criptografia RSA, que sustenta a segurança da sociedade da internet moderna, baseia-se na geração de números primos gigantescos e na dificuldade de sua multiplicação (a dificuldade da fatoração em números primos) como base de sua segurança. Portanto, a tecnologia para identificar instantaneamente se um número gigante é primo não é exagero dizer que é a tecnologia que sustenta os fundamentos da sociedade digital.

Além disso, na programação competitiva (como AtCoder e Codeforces), o teste de primalidade é um tema frequente. Em situações onde as restrições são para entradas gigantescas como $N \le 10^{18}$, e você precisa realizar dezenas de milhares de testes de primalidade em menos de 1 segundo, algoritmos tradicionais e ingênuos certamente não conseguirão ser executados a tempo (Time Limit Exceeded: TLE).

Neste artigo, começaremos com algoritmos de teste de primalidade ingênuos, passaremos pelo “Teste de Fermat”, que é um método de teste de primalidade probabilístico, e explicaremos detalhadamente o algoritmo de altíssima velocidade de nível mais forte na prática, o “Teste de Primalidade de Miller-Rabin”, que superou as fraquezas do anterior, desde a base matemática até uma implementação altamente otimizada em C++. Em particular, para inteiros de 64 bits ($N < 2^{64}$), explicaremos em detalhes o método que vai além do teste probabilístico e pode “testar a primalidade com 100% de certeza (teste determinístico)”, e forneceremos o código-fonte em C++ que pode ser usado diretamente na prática.

1. Fundamentos do Teste de Primalidade e Divisão por Tentativa (Trial Division)

Um número primo (Prime number) é um número natural maior ou igual a 2 que não possui divisores positivos além de 1 e ele mesmo. Seguindo estritamente a definição de número primo, para determinar se um inteiro $N$ é primo, podemos tentar dividir $N$ por todos os inteiros de $2$ a $N-1$, e se ele nunca for divisível, podemos julgar que é um número primo; se for divisível mesmo uma vez, é um número composto (não é um número primo).

No entanto, a complexidade de tempo deste método é $O(N)$, e se $N$ for um número gigante como $10^{18}$, até mesmo computadores modernos levariam uma quantidade enorme de tempo para calcular.

Otimização da Divisão por Tentativa: Busca até $\sqrt{N}$

Quando um número composto $N$ é expresso como $a \times b = N$ ($a \le b$), é certo que $a \le \sqrt{N}$. Portanto, não é necessário iterar o loop de teste de primalidade até $N-1$; é suficiente verificar até $\sqrt{N}$.

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


#include <iostream>

// Teste de primalidade por divisão por tentativa (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;

 // Verificar apenas números ímpares a partir de 3
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

A complexidade de tempo deste algoritmo é $O(\sqrt{N})$. Se for em torno de $N \le 10^{12}$, pode ser calculado instantaneamente, mas se $N \approx 10^{18}$, o número de loops será de cerca de $10^9$ vezes, e mesmo com o compilador C++, levará de centenas de milissegundos a vários segundos, tornando-o inadequado para múltiplos testes.

2. Teste de Fermat: O Início do Teste de Primalidade Probabilístico

O que foi concebido para superar as limitações do método de divisão por tentativa foi o “Algoritmo Probabilístico” usando teoremas da teoria dos números. Um exemplo representativo é o “Teste de Primalidade de Fermat” que utiliza o Pequeno Teorema de Fermat.

O Pequeno Teorema de Fermat

Este teorema, descoberto por Pierre de Fermat, afirma o seguinte:

Para qualquer número primo $p$ e qualquer inteiro $a$ coprimo com $p$ (que não seja um múltiplo de $p$), a seguinte congruência é válida.
$$ a^{p-1} \equiv 1 \pmod p $$

Tomando a contrapositiva deste teorema, podemos dizer que “Se para um inteiro $N$ e um inteiro $a$ coprimo com $N$, $a^{N-1} \not\equiv 1 \pmod N$, então $N$ é definitivamente um número composto”. Usando esta propriedade, o Teste de Fermat seleciona uma base aleatória $a$ para o número $N$ a ser testado e verifica se o cálculo de $a^{N-1} \pmod N$ resulta em $1$.

Exponenciação Modular Rápida (Exponenciação Binária)

Para realizar o teste de Fermat, é necessário calcular rapidamente a potência gigante $a^{N-1} \pmod N$. Para isso, usamos o método de “Exponenciação Modular / Binária”. A complexidade de tempo é $O(\log N)$, tornando-o extremamente rápido.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Cálculo de a^b mod m usando exponenciação binária
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;
}

※ Aqui, para evitar overflow, estamos usando a extensão do GCC/Clang __int128_t (inteiro de 128 bits) para manter o produto intermediário.

Pseudoprimos e Números de Carmichael

O Teste de Fermat é muito poderoso, mas tem uma fraqueza fatal. É a existência de números tais que, mesmo $N$ sendo um número composto, $a^{N-1} \equiv 1 \pmod N$ é válido para todos os $a$ (onde $a$ é coprimo com $N$).

Tais números são chamados de “pseudoprimos absolutos” ou “números de Carmichael”. O menor número de Carmichael é $561 = 3 \times 11 \times 17$. Como os números de Carmichael existem, não é possível realizar um teste determinístico de “100% de probabilidade” apenas com o Teste de Fermat. Não importa quantos $a$ diferentes você tente, números como $561$ sempre se farão passar por primos (enganarão o teste).

3. Teste de Primalidade de Miller-Rabin

O que superou de forma brilhante a fraqueza do Teste de Fermat (a existência dos números de Carmichael) foi o “Teste de Primalidade de Miller-Rabin” concebido por Gary L. Miller e Michael O. Rabin. Atualmente, como um algoritmo prático de teste de primalidade de alta velocidade, é o mais amplamente utilizado em bibliotecas internas de várias linguagens de programação e na geração de chaves para sistemas criptográficos.

Princípio Matemático

O algoritmo de Miller-Rabin, além do Pequeno Teorema de Fermat, utiliza a propriedade de que “em um anel de resíduos módulo um primo ($\mathbb{Z}/p\mathbb{Z}$), as soluções para $x^2 \equiv 1 \pmod p$ limitam-se a $x \equiv 1$ ou $x \equiv -1$” (ao usar um número composto como módulo, outras raízes quadradas não triviais podem existir).

Subtrair $1$ do número ímpar $N$ a ser testado, $N-1$, resultará sempre em um número par. Portanto, dividimos $N-1$ por $2$ o máximo possível e expressamos no seguinte formato:

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

(Onde $d$ é um número ímpar e $s \ge 1$)

Para qualquer base $a$ ($1 < a < N-1$), verificamos se $a^{N-1} \equiv 1 \pmod N$ de acordo com o Pequeno Teorema de Fermat, mas realizamos esse cálculo em etapas. Especificamente, repetimos a elevação ao quadrado em ordem: $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$.

A condição para o teste de Miller-Rabin julgar $N$ como “sendo primo (ou sendo um primo com forte probabilidade)” é que qualquer uma das seguintes afirmações seja verdadeira.

$a^d \equiv 1 \pmod N$
Existe algum $r$ ($0 \le r < s$) tal que $a^{d \cdot 2^r} \equiv -1 \pmod N$ é satisfeito. ※ Na operação de módulo em C++, $-1 \pmod N$ se torna $N-1$.

Se $N$ for um número primo, esta condição será necessariamente satisfeita para qualquer $a$. Por outro lado, foi matematicamente provado que se $N$ for um número composto, a probabilidade de satisfazer essa condição (a probabilidade de ser enganado) ao escolher um $a$ aleatório é de $\frac{1}{4}$ ou menos. Se você realizar $k$ testes independentes, a probabilidade de um falso positivo será menor ou igual a $\left(\frac{1}{4}\right)^k$, podendo ser praticamente considerada zero. Não há números que possam “enganar absolutamente” como os números de Carmichael.

Fluxo do Algoritmo de Miller-Rabin (Fluxograma Mermaid)

A figura a seguir mostra o fluxo lógico de uma única rodada do teste de primalidade de Miller-Rabin (teste para uma única base $a$).

graph TD Start["Início do Teste (Entrada: N, a)"] --> CalcDS["Calcular d (ímpar) e s que satisfazem N-1 = d * 2^s"] CalcDS --> CalcX["Calcular x = a^d mod N"] CalcX --> CheckX1{"x == 1 ou x == N-1 ?"} CheckX1 -- "Yes" --> ReturnTrue["Pode ser primo (Probably Prime)"] CheckX1 -- "No" --> LoopStart["Iniciar loop de r = 1 até s-1"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "No" --> ReturnFalse["Certamente composto (Composite)"] LoopCondition -- "Yes" --> SquareX["Calcular x = (x * x) mod N"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Yes" --> ReturnTrue CheckXMinus1 -- "No" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Yes" --> ReturnFalse CheckXOne -- "No" --> LoopNext["Incrementar r em 1 e prosseguir"] LoopNext --> LoopCondition

4. Teste Determinístico para Inteiros de 64 Bits

O teste de primalidade de Miller-Rabin é inerentemente um algoritmo “probabilístico”, mas se o limite superior de $N$ for fixo, você pode realizar o teste de primalidade com “100% de certeza” testando todos de um conjunto específico de várias bases $a$. Isso é chamado de Teste Determinístico de Miller-Rabin (Deterministic Miller-Rabin Test).

Pesquisas de Jim Sinclair e outros revelaram que para todos os inteiros de $N < 2^{64}$ (aproximadamente $1.8 \times 10^{19}$), um julgamento determinístico suficiente e completo é possível se você escolher e testar os seguintes $7$ números primos como a base $a$.

Lista de bases $a$ a serem testadas: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

Alternativamente, é bem conhecido que ao usar o seguinte conjunto de $12$ números primos, também é possível determinar perfeitamente para $N < 2^{64}$ e abaixo. {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

Desta vez, a fim de aumentar a simplicidade e confiabilidade do algoritmo, adotaremos um método que usa os últimos $12$ números primos como base (ou as $7$ bases mais otimizadas). Na implementação em C++, otimizamos dividindo os intervalos com desvios condicionais para manter o número de testes no mínimo.

5. Implementação Avançada em C++ (Highly Optimized C++ Implementation)

Agora, resumiremos as teorias matemáticas e o design do algoritmo discutidos até agora, e apresentaremos o código de implementação da função de teste de primalidade de Miller-Rabin de nível mais forte em C++ moderno.

Pontos de Implementação

Evitar o overflow da multiplicação de inteiros de 64 bits: Quando $N \approx 10^{18}$, $x \times x$ na multiplicação modular atinge o máximo de $10^{36}$, ultrapassando facilmente o valor máximo de $1.8 \times 10^{19}$ de um inteiro normal de 64 bits (uint64_t ou long long). Para resolver este problema, usamos a extensão do tipo __int128_t (ou unsigned __int128) do GCC e Clang e pegamos o módulo após calcular com precisão de 128 bits. Isso permite multiplicações modulares rápidas sem usar algoritmos complexos.
Seleção da base determinística: Se o valor de $N$ for pequeno, otimizamos para que precisemos testar apenas algumas bases.

Código-Fonte C++ Completo

Abaixo, mostramos o código-fonte finalizado pronto para uso prático. Este código pode ser copiado e usado como está em ambientes como de programação competitiva.

 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;

// Fast (a * b) mod m using 128-bit integers
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// Cálculo de (base^exp) mod m por exponenciação binária
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;
}

// Teste determinístico de inteiros de 64 bits pelo Teste de Primalidade de Miller-Rabin
bool is_prime_miller_rabin(uint64_t n) {
 // Pré-julgamento de valores limite e pequenos números primos
 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;

 // Decompor n-1 no formato d * 2^s
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // Lista de bases usadas para determinação
 // Otimização para minimizar o número de bases testadas de acordo com o tamanho de N
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 7 bases que são determinísticas para todos os números N < 2^64
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // Executar teste para cada base
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // Se a for múltiplo de n, não pode ser julgado, mas não é primo

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // Primeira condição atendida, para a próxima base

 bool composite = true;
 // Loop de s-1 vezes (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // Segunda condição atendida, possível primo
 break;
 }
 }

 // Se nenhuma condição for atendida, é definitivamente um número composto
 if (composite) return false;
 }

 // Se as condições forem atendidas em todas as bases, definitivamente é primo
 return true;
}

int main() {
 // Casos de teste de exemplo
 vector<uint64_t> test_cases = {
 1000000007, // Número primo famoso
 998244353, // Número primo famoso
 1000000000000000003, // Número primo próximo de 10^18
 1000000000000000007, // Número composto (10^18 + 7)
 561, // Número de Carmichael (Número composto)
 18446744073709551557ULL // Um dos maiores primos perto de 2^64
 };

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

 return 0;
}

6. Avaliação de Complexidade e Desempenho do Algoritmo

Consideraremos o desempenho do algoritmo implementado.

Complexidade de Tempo (Time Complexity)

Divisão por tentativa: $O(\sqrt{N})$
Teste de Fermat: Cálculo de potência $O(\log N) \times k$ ($k$ é o número de tentativas)
Método de Miller-Rabin: Cálculo de potência e loop $O(\log N) \times k$

No ambiente de 64 bits ($N \le 2^{64}$), o método determinístico de Miller-Rabin acima verificará no máximo $7$ bases. Portanto, pode-se considerar uma constante $k \le 7$, e a complexidade de tempo total é estritamente $O(\log N)$. Mesmo no caso máximo ($N \approx 10^{19}$), o número de etapas de execução caberá em não mais que $7 \times 64 = 448$ etapas de operações básicas, e o tempo de execução é menor que alguns microssegundos (segundos $10^{-6}$). Em comparação com o $O(\sqrt{N})$ (cerca de $4 \times 10^9$ loops) do método de divisão por tentativa, uma aceleração de milhões de vezes foi alcançada.

Otimização Adicional: Multiplicação de Montgomery (Montgomery Multiplication)

Na implementação deste artigo, a extensão do tipo __int128_t de 128 bits é usada para a divisão (operação de módulo %). Mesmo com CPUs modernas, a divisão de inteiros (instrução DIV) é uma instrução de alto custo que requer dezenas de ciclos em comparação com a adição e multiplicação.

Os criadores de bibliotecas e programadores competitivos em busca de otimização extrema ocasionalmente empregarão um método chamado Multiplicação de Montgomery (Montgomery Multiplication). A multiplicação de Montgomery é um algoritmo surpreendente que substitui a operação cara de módulo (divisão) apenas por “deslocamentos de bits e multiplicações”, mapeando os números em um “espaço de Montgomery” especial. Ao incorporar isso na multiplicação modular do teste de Miller-Rabin, é possível aumentar ainda mais a velocidade de execução em cerca de duas a três vezes. Sendo este um tema muito profundo, eu gostaria de explicá-lo em detalhes em outro artigo.

7. Resumo

Neste artigo, explicamos tudo de uma vez, desde os fundamentos dos testes de primalidade até o conteúdo avançado. Vamos revisar os pontos principais.

O Método de Divisão por Tentativa é confiável, mas como a complexidade computacional é $O(\sqrt{N})$, falta praticidade quando $N$ excede $10^{12}$.
O Teste de Fermat é muito rápido com $O(\log N)$, mas tem uma fraqueza fatal de ser enganado por pseudoprimos absolutos, como os números de Carmichael.
O Teste de Primalidade de Miller-Rabin é o algoritmo mais prático e mais forte que resolve a fraqueza do Teste de Fermat.
Na implementação em C++, o uso de __int128_t permite o tratamento seguro do overflow da multiplicação de inteiros de 64 bits.
Se estiver dentro do intervalo de inteiros de 64 bits ($N < 2^{64}$), selecionando $7$ ou $12$ números primos específicos como base, é possível realizar o teste de primalidade deterministicamente (100% preciso) em vez de probabilisticamente.

Testes rápidos de primalidade são uma técnica inevitável nos cálculos que lidam com números gigantescos. O código-fonte de Miller-Rabin em C++ fornecido neste artigo é robusto e pode ser utilizado como está na prática. Por favor, tente utilizá-lo em seus próprios projetos ou competições de algoritmos.

graph LR TrialDivision["Divisão por Tentativa (O(√N))"] --> Fermat["Teste de Fermat (O(log N), tem fraqueza)"] Fermat --> MillerRabin["Método Miller-Rabin (O(log N), pode ser determinístico)"] MillerRabin --> Montgomery["+ Multiplicação Montgomery (Aceleração por fator constante)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

O mundo dos algoritmos onde a programação e a matemática se cruzam é muito bonito e profundo. Esperamos que isso o ajude em seu aprendizado futuro.

Referência:

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.

【Explicação de Matemática】Explicando o mecanismo da criptografia RSA para que até alunos do ensino médio entendam

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

Uma das tecnologias que sustenta a segurança da nossa sociedade baseada na internet desde a sua base é a “Criptografia RSA”. Muitas das comunicações que usamos casualmente todos os dias, como pagamentos com cartão de crédito em compras online, troca de mensagens em redes sociais com amigos, ou o envio e recebimento de informações confidenciais de empresas, são protegidas pela criptografia RSA e suas tecnologias sucessoras.

No entanto, ao ouvir a palavra “criptografia”, você pode imaginar máquinas de cifra complexas como as que aparecem em filmes de espionagem, ou uma matemática super avançada que apenas alguns gênios conseguem entender. É verdade que a teoria criptográfica moderna é baseada em matemática avançada, mas o mecanismo fundamental da criptografia RSA pode ser plenamente compreendido com o conhecimento de matemática ensinado no ensino médio (propriedades de números inteiros, números primos, congruências, etc.).

Neste artigo, usaremos o conhecimento da matemática do ensino médio como ponto de partida para explicar passo a passo e de forma aprofundada os princípios matemáticos pelos quais a criptografia RSA funciona e por que é tão difícil de quebrar. Explicarei cuidadosamente usando exemplos concretos para que mesmo aqueles que têm um pouco de dificuldade com matemática possam entender.

1. Criptografia de Chave Simétrica e Criptografia de Chave Pública

Antes de mergulhar no mecanismo matemático da criptografia RSA, vamos primeiro revisar a ideia básica de criptografia. Os métodos criptográficos podem ser amplamente divididos em dois tipos: “Criptografia de chave simétrica” e “Criptografia de chave pública”.

1.1 Limitações da Criptografia de Chave Simétrica

Muitos dos métodos de criptografia usados há muito tempo são chamados de “Criptografia de chave simétrica”. Este é um método em que a mesma chave é usada tanto para “criptografia” (converter uma mensagem em um texto cifrado secreto) quanto para “descriptografia” (retornar o texto cifrado à mensagem original).

Por exemplo, suponha que a Alice vá enviar uma carta secreta ao Bob. A Alice coloca a carta em uma caixa e a tranca usando um cadeado (chave simétrica). Para o Bob abrir essa caixa, ele precisará ter a mesma chave que a Alice usou.

Este método tem um grande problema: o “Problema de distribuição de chaves”. Quando Alice e Bob, que estão distantes, se comunicam pela primeira vez, como eles poderiam compartilhar a chave sem serem interceptados? Se a chave for roubada por terceiros enquanto é enviada por correio, toda a comunicação criptografada subsequente ficará totalmente exposta.

1.2 Uma Invenção Revolucionária: “Criptografia de Chave Pública”

A “Criptografia de chave pública” foi idealizada para resolver esse problema de distribuição de chaves. A criptografia RSA é um tipo deste sistema.

Na criptografia de chave pública, usamos duas chaves diferentes: uma “chave para criptografar (chave pública)” e uma “chave para descriptografar (chave privada)”.

O destinatário, Bob, cria um par de “chave pública” e “chave privada”.
Bob publica a “chave pública” para todo o mundo (não importa quem a obtenha).
A remetente, Alice, criptografa a mensagem usando a “chave pública” de Bob e a envia.
A mensagem criptografada só pode ser descriptografada com a “chave privada” que apenas Bob possui.

Comparando isso com o exemplo do cadeado: Bob cria vários “cadeados abertos (chaves públicas)” e os distribui pelo mundo. Alice coloca sua mensagem destinada a Bob em uma caixa e a tranca fechando um dos cadeados que encontrou pertencente a Bob. Uma vez que o cadeado é fechado, ele só pode ser aberto com a “chave mestra (chave privada)” que Bob possui. Mesmo que alguém roube a caixa no meio do caminho, essa pessoa não conseguirá abri-la porque não tem a chave mestra.

graph TD A["Alice (Remetente)"] --> B["Texto Plano (Mensagem)"] B --> C["Processo de Criptografia"] D["Chave Pública do Bob (Disponível para qualquer um)"] --> C C --> E["Enviado via Internet: Texto Cifrado"] E --> F["Processo de Descriptografia"] G["Chave Privada do Bob (Mantida apenas pelo Bob)"] --> F F --> H["Texto Plano Restaurado (Mensagem)"] H --> I["Bob (Destinatário)"]

Para implementar este sistema revolucionário, é necessária algum tipo de “função unidirecional (um quebra-cabeça matemático de mão única)”, que significa que “é fácil criptografar com a chave pública, mas é absolutamente impossível descriptografar sem a chave privada”. Como peça para esse quebra-cabeça, a atenção se voltou para os “números primos”, algo que conhecemos bem.

2. Base Matemática 1 Sustentando a Criptografia RSA: Números Primos e Fatoração em Números Primos

A segurança da criptografia RSA é baseada no fato matemático de que “a fatoração de números gigantes em números primos é extremamente difícil”.

2.1 O que são Números Primos?

Os números primos são “números naturais maiores que 1 que só podem ser divididos por 1 e por si mesmos”. Exemplo: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Os números primos são como “átomos” para todos os números inteiros. Qualquer número natural pode ser decomposto na forma de uma multiplicação de números primos. Isso é chamado de fatoração em números primos. Por exemplo, como em $60 = 2^2 \times 3 \times 5$, ignorando a ordem, o fato de que pode ser fatorado em números primos de apenas uma única forma é conhecido como o “Teorema Fundamental da Aritmética”.

2.2 A Dificuldade da Fatoração em Números Primos (Função Unidirecional)

O importante aqui é a assimetria: “A multiplicação é fácil, mas a fatoração em números primos é difícil”.

Por exemplo, tente calcular de cabeça a multiplicação destes dois números primos: $11 \times 13 = ?$ Isto é fácil. A resposta é $143$.

Então, que tal o próximo número? Por favor, fatore $323$ em números primos. E então? Deve demorar um pouco. (A resposta é $17 \times 19$).

Quando os números são pequenos, até humanos conseguem calcular de alguma forma, mas quando os números ficam grandes, o cálculo se torna explosivamente difícil, mesmo usando computadores. Na criptografia RSA moderna, usamos um número $N = p \times q$ obtido pela multiplicação de números primos incrivelmente gigantes $p$ e $q$ de 2048 bits (cerca de 600 dígitos decimais).

Quando fornecidos dois números primos gigantes $p$ e $q$, calcular $N$ leva apenas um instante (menos de um milissegundo) para um computador. No entanto, reversamente, receber apenas $N$ e encontrar os $p$ e $q$ originais leva tanto tempo que não seria resolvido mesmo rodando os supercomputadores mais rápidos da atualidade por trilhões de anos.

Essa “assimetria computacional (um caminho é fácil, o caminho inverso é difícil)” é a base que cria o relacionamento entre a chave pública e a chave privada.

3. Base Matemática 2 Sustentando a Criptografia RSA: Congruência (Aritmética Modular)

Os cálculos da criptografia RSA não são realizados com adição e multiplicação onde os números ficam infinitamente grandes, como costumamos usar, mas sim no mundo dos “restos” quando divididos por um certo número. Isso é chamado de congruência (aritmética modular).

3.1 A Matemática do Relógio

A aritmética modular é frequentemente comparada com a “matemática do relógio”. Supondo que agora são 10 horas, que horas serão daqui a 5 horas? $10 + 5 = 15$ horas, mas em um relógio normal de 12 horas, respondemos “3 horas”. Isso ocorre porque o resto de 15 dividido por 12 é 3.

No mundo da matemática, isso é escrito da seguinte forma:

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

Lê-se “15 e 3 são congruentes módulo 12 (os restos quando divididos por 12 são iguais)”.

3.2 Propriedades Básicas da Congruência

A congruência possui propriedades muito úteis e semelhantes a equações (igualdades $=$). Vamos assumir que o módulo (número pelo qual dividimos) é $N$. Quando $a \equiv b \pmod N$ e $c \equiv d \pmod N$, o seguinte é verdadeiro:

Adição: $a + c \equiv b + d \pmod N$
Subtração: $a - c \equiv b - d \pmod N$
Multiplicação: $a \times c \equiv b \times d \pmod N$
Exponenciação: $a^k \equiv b^k \pmod N$ ($k$ é um número natural)

Particularmente importante é a propriedade da “exponenciação”. Isso significa que “o resto de uma potência é igual à potência do resto”. Por exemplo, imagine que você queira encontrar o resto de $7^{100}$ dividido por $5$. Seria muito difícil multiplicar o $7$ por ele mesmo 100 vezes e depois dividir por $5$, mas se usarmos a propriedade da congruência, como $7 \equiv 2 \pmod 5$, então $7^{100} \equiv 2^{100} \pmod 5$, permitindo simplificar drasticamente o cálculo. No mundo da criptografia lidamos com potências de números extremamente grandes, então essa propriedade é indispensável.

4. Base Matemática 3 Sustentando a Criptografia RSA: Função de Euler e Teorema de Euler

A partir daqui, entra a matemática mágica que forma o núcleo da criptografia RSA. Apresentamos o “Teorema de Euler”, que é uma generalização do “Pequeno Teorema de Fermat”.

4.1 A Função Totiente de Euler $\phi(N)$

A função totiente de Euler (função $\phi$) é uma função que, para um determinado número natural $N$, retorna “a quantidade de números naturais de 1 até $N$ que são coprimos de $N$ (ou seja, seu máximo divisor comum é 1)”.

Vamos olhar alguns exemplos.

$\phi(5)$: Dentre 1, 2, 3, 4, 5, os números coprimos de 5 são 1, 2, 3, 4; ou seja, 4 números. Portanto, $\phi(5) = 4$.
$\phi(6)$: Dentre 1, 2, 3, 4, 5, 6, os números coprimos de 6 são 1, 5; ou seja, 2 números. Portanto, $\phi(6) = 2$.

[Propriedade especial no caso de números primos] Quando $p$ é um número primo, todos os números de 1 até $p-1$ são coprimos de $p$. Logo,

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

[Propriedade especial no caso de um produto de números primos] Para dois números primos distintos $p$ e $q$, quando se estabelece que $N = p \times q$, $\phi(N)$ pode ser facilmente obtido pelo seguinte cálculo:

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

Essa propriedade funciona como a “porta dos fundos secreta (alçapão)” na criptografia RSA. Alguém que conhece $p$ e $q$ (o criador das chaves) pode calcular $\phi(N)$ em um instante, mas um terceiro que conhece apenas $N$ não pode determinar $\phi(N)$ a menos que fatore $N$ em números primos.

4.2 Teorema de Euler

Leonhard Euler usou esse $\phi(N)$ para provar o seguinte belo teorema.

Teorema de Euler: Quando um inteiro $a$ e $N$ são coprimos, a seguinte congruência é verdadeira:

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

Isso é uma propriedade surpreendente que diz: “quando você multiplica um certo número $a$ por ele mesmo $\phi(N)$ vezes e divide por $N$, o resto será sempre $1$”. (Se $N$ for um número primo $p$, torna-se $a^{p-1} \equiv 1 \pmod p$, que é chamado de Pequeno Teorema de Fermat).

Vamos transformar este Teorema de Euler. Multiplicamos ambos os lados por $a$ mais uma vez.

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

Além disso, para qualquer número inteiro $k$, $a^{k \cdot \phi(N)}$ também será $1^k = 1$, de modo que a seguinte fórmula é válida:

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

Esta exata equação é o princípio fundamental que faz com que a mágica da criptografia RSA de “retornar ao original quando descriptografada após criptografar” funcione.

5. Algoritmo da Criptografia RSA: Passos para Geração de Chaves, Criptografia e Descriptografia

Agora que temos o conhecimento básico, vamos olhar para os passos concretos da criptografia RSA. A criptografia RSA é dividida principalmente em três fases: “1. Geração de Chaves”, “2. Criptografia” e “3. Descriptografia”.

flowchart TD A1["1. Escolher os primos p, q"] --> A2["Calcular N = p × q"] A1 --> A3["Calcular φ(N) = (p-1)(q-1)"] A3 --> A4["Escolher e coprimo de φ(N)"] A3 --> A5["Calcular d tal que e × d ≡ 1 (mod φ(N))"] A2 --> A6["Chave Pública (N, e)"] A4 --> A6 A5 --> A7["Chave Privada d"] B1["2. Mensagem em Texto Plano M"] --> B2["Calcular C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Enviar Texto Cifrado C"] B3 --> C1["3. Receber Texto Cifrado C"] C1 --> C2["Calcular M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Obter a Mensagem em Texto Plano original M"]

5.1 Geração de Chaves (Key Generation)

Bob, o destinatário, gera sua “chave pública” e “chave privada”.

Seleção dos primos: Ele escolhe dois grandes números primos $p$ e $q$ aleatoriamente.
Cálculo do módulo $N$: Ele calcula $N = p \times q$. Este $N$ é tornado público.
Cálculo de $\phi(N)$: Ele calcula a função de Euler $\phi(N) = (p - 1)(q - 1)$. Este número é um segredo apenas do Bob.
Seleção da chave pública $e$: Ele escolhe um inteiro $e$ tal que $1 < e < \phi(N)$ e que $e$ seja coprimo de $\phi(N)$.
Cálculo da chave privada $d$: Ele encontra um inteiro $d$ que satisfaça a seguinte condição: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Isso significa “um número $d$ tal que, quando $e \times d$ é dividido por $\phi(N)$, o resto é $1$”.

Com isso, as chaves estão prontas.

Chave Pública: O par $(N, e)$. Publicado para todo o mundo.
Chave Privada: $d$. Jamais revelado a ninguém.

5.2 Criptografia (Encryption)

Suponha que Alice queira enviar uma mensagem secreta $M$ para Bob. (Assumimos que $M$ é um texto convertido em valor numérico, e que $0 \le M < N$). Alice usa a chave pública do Bob, $(N, e)$, para fazer o seguinte cálculo:

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

Ela calcula “o resto $C$ obtido após elevar a mensagem $M$ à potência de $e$, e dividir por $N$”. Esse $C$ é o texto cifrado.

5.3 Descriptografia (Decryption)

Bob recebe o texto cifrado $C$. Bob usa sua chave privada $d$ para calcular o seguinte:

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

Ao calcular “o resto de elevar o texto cifrado $C$ à potência de $d$, e dividir por $N$”, incrivelmente a mensagem original $M$ é restaurada!

6. Por que retorna ao original na descriptografia? (Prova Matemática)

Você pode se perguntar: “Por que simplesmente elevar $C$ à potência de $d$ retorna ao $M$ original?”. Aqui, o “Teorema de Euler” mencionado anteriormente mostra o seu poder.

Vamos substituir a equação de criptografia $C = M^e$ na equação de descriptografia $C^d \pmod N$.

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

Aqui, lembre-se do Passo 5 da Geração de Chaves. Ao criar $d$, Bob o escolheu de forma que $e \times d \equiv 1 \pmod{\phi(N)}$. Isso significa que “$ed$ é um múltiplo de $\phi(N)$ somado a $1$”. Podemos escrevê-lo da seguinte maneira, utilizando um inteiro $k$:

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

Substituímos isso no expoente e o decompomos usando as leis dos expoentes:

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

Aqui, assumindo que a mensagem $M$ e $N$ são coprimos, a partir do Teorema de Euler, temos $M^{\phi(N)} \equiv 1 \pmod N$.

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

Portanto, a seguinte equação é perfeitamente estabelecida:

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

Como a Alice não conhece $d$, e o espião também não conhece $d$, apenas Bob, que possui $d$, consegue extrair o $M$ a partir de $C$.

7. Exemplo Concreto: Vamos vivenciar o RSA calculando à mão usando pequenos números primos

Vamos tentar enviar uma comunicação criptografada de Alice para Bob usando números pequenos (números primos) de fato.

[Fase de Geração de Chaves do Bob]

Escolhe-se dois números primos $p=11$, $q=13$.
Calcula-se $N = 11 \times 13 = 143$.
Calcula-se $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Escolhe-se uma chave pública $e$ coprima de $\phi(N)=120$. Aqui usaremos $e=7$.
Calcula-se a chave privada $d$. Buscamos um $d$ que satisfaça $7 \times d \equiv 1 \pmod{120}$. Na equação $7d = 120k + 1$, quando $k=6$, temos $721$, e $721 \div 7 = 103$. Portanto, $d = 103$.

Chave Pública: $(N=143, e=7)$
Chave Privada: $d=103$

[Fase de Criptografia da Alice] Suponha que ela queira enviar a mensagem $M = 9$. Fórmula: $C \equiv 9^7 \pmod{143}$ $9^7 = 4.782.969$. Dividindo isso por 143, dá $33447$ com resto $48$. O texto cifrado se tornou $C = 48$.

[Fase de Descriptografia do Bob] Bob recebe o texto cifrado $C = 48$ e o descriptografa usando a chave privada $d = 103$. Fórmula: $M \equiv 48^{103} \pmod{143}$ Se executarmos (48 ** 103) % 143 na calculadora, brilhantemente o resultado será “9”! A mensagem original foi recebida com sucesso.

8. Como encontrar a Chave Privada $d$: Algoritmo de Euclides Estendido

No exemplo calculado à mão, adivinhamos o valor de $k$ para encontrar $d=103$, mas quando o número atinge centenas de dígitos, esse método se torna impossível. Nos programas reais usamos um algoritmo chamado “Algoritmo de Euclides Estendido”.

Resolver $7d \equiv 1 \pmod{120}$ é o mesmo que encontrar inteiros $d, y$ que satisfaçam $7d + 120y = 1$. Ao realizar os passos do Algoritmo de Euclides ao reverso, podemos encontrar isso mecanicamente.

$120 \div 7 = 17$ com resto $1$
Rearranjando isso, temos $1 = 120 - 17 \times 7$
Em outras palavras, $-17 \times 7 \equiv 1 \pmod{120}$

No mundo do módulo $120$, $-17$ tem o mesmo significado que $120 - 17 = 103$. Assim, o $d = 103$ pode ser encontrado em um instante. Este método consegue calcular de forma extremamente rápida por mais gigante que o número seja.

9. Outra Face da Criptografia RSA: Assinatura Digital

A parte fantástica da criptografia RSA é que, se invertermos as funções da chave pública e chave privada, ela também pode ser usada como uma “Assinatura Digital”.

Na criptografia os passos eram: “Criptografar com a chave pública $\Rightarrow$ Descriptografar com a chave privada”, Mas na assinatura digital seguimos os passos: “Criptografar com a chave privada $\Rightarrow$ Descriptografar com a chave pública”.

flowchart TD A1["1. Alice cria a assinatura com a chave privada"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Envia a mensagem M e a assinatura S"] A3 --> B1["2. Bob verifica a assinatura com a chave pública"] B1 --> B2["Calcula M' ≡ S^e (mod N)"] B2 --> B3["Verifica se M' e M coincidem"]

A Alice transforma a mensagem usando sua própria chave privada $d$ (essa será a assinatura $S$) e envia ao Bob. O Bob faz o cálculo de verificação usando a chave pública de Alice, $e$. Se o resultado do cálculo for igual à mensagem original, isso prova simultaneamente que “os dados só poderiam ter sido criados pela chave privada da Alice” e que “a mensagem não foi adulterada no meio do caminho”.

10. Sentindo a Criptografia RSA na Prática com Código

O cálculo de potências que seria difícil de fazer à mão pode ser implementado muito facilmente usando Python. A seguir, um código Python para você experienciar a lógica central da criptografia 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):
 """Calcular o máximo divisor comum"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Encontrar a chave privada d (usando a função embutida a partir do Python 3.8)"""
 return pow(e, -1, phi)

# 1. Geração de chaves
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Chave Pública: (N={N}, e={e}), Chave Privada: d={d}")

# 2. Criptografia
message = 9
ciphertext = pow(message, e, N)
print(f"Texto Cifrado: {ciphertext}")

# 3. Descriptografia
decrypted_message = pow(ciphertext, d, N)
print(f"Mensagem Descriptografada: {decrypted_message}")

Como a função pow(base, exp, mod) do Python usa internamente um algoritmo rápido chamado “exponenciação binária (ou método das multiplicações repetidas)”, o cálculo termina em um instante mesmo para números com centenas de dígitos.

11. Conclusão e Futuro das Tecnologias de Criptografia

Nós desvendamos o mecanismo da criptografia RSA tendo como base a matemática do ensino médio.

A dificuldade da fatoração em números primos: É fácil calcular $p \times q = N$, mas é extremamente difícil encontrar $p, q$ a partir de $N$.
Congruências e Teorema de Euler: Devido à regra $a^{\phi(N)} \equiv 1 \pmod N$, completa-se o mágico alçapão onde “a exponenciação por um certo número retorna ao estado original”.
Chave Pública e Chave Privada: Qualquer um pode criptografar, mas apenas o destinatário legítimo consegue descriptografar.

O $N$ da criptografia RSA usada atualmente possui mais de 600 dígitos, e mesmo que todos os supercomputadores do mundo se juntassem para faturar esse número em primos, levaria um tempo maior do que a idade do universo. No entanto, se o “computador quântico”, que vem sendo pesquisado ativamente nos últimos anos, se tornar prático no futuro, essa fatoração poderá ser resolvida em instantes pelo “Algoritmo de Shor”. Por esse motivo, criptografias “resistentes a computadores quânticos”, que não poderiam ser quebradas nem mesmo por eles, estão sendo desenvolvidas a um ritmo acelerado pelo mundo todo.

A matemática avançada que costumamos considerar “inútil”, na verdade, protege nosso dia a dia na sua essência mais profunda. A criptografia RSA é um excelente material didático que nos ensina essa profundidade e beleza da matemática. Ficaria muito feliz se através deste artigo você pudesse sentir um pouco do fascínio da criptografia e da matemática.