Math on kenji.blog

【Para Iniciantes】Desvendando a Estrutura Matemática do Modelo Transformer

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

Introdução: Por que aprender a matemática do Transformer?

Não é exagero dizer que a arquitetura “Transformer” reescreveu a história do Processamento de Linguagem Natural (NLP) e da IA moderna como um todo. Proposto pela primeira vez no artigo “Attention Is All You Need”, publicado por pesquisadores do Google em 2017, este modelo atua como o coração dos Grandes Modelos de Linguagem (LLMs) que dominam o mundo hoje, como a série GPT da OpenAI (a tecnologia base do ChatGPT), o BERT do Google e o Claude da Anthropic.

No entanto, embora vejamos frequentemente explicações qualitativas sobre o funcionamento do Transformer, como “usar Attention (mecanismo de atenção) para entender o contexto”, a realidade é que existem surpreendentemente poucas explicações aprofundadas para iniciantes sobre a estrutura matemática por trás disso. Para realmente entender como a IA processa “palavras” como “fórmulas matemáticas” e gera textos incrivelmente naturais, é essencial desvendar seus mecanismos matemáticos.

Neste artigo, direcionado a pessoas com conhecimento básico em matemática e programação (que compreendem conceitos de matrizes e derivadas em nível de ensino médio), explicaremos de forma completa e acessível as estruturas matemáticas que formam o núcleo do Transformer: o mecanismo de “Self-Attention”, o modelo “Query, Key, Value (Q/K/V)”, a “Normalização com a função Softmax” e o “Positional Encoding”.

Você pode se sentir sobrecarregado pela sucessão de fórmulas, mas cada cálculo tem um “significado” claro. Quando terminar de ler este artigo, você deverá compreender que o Transformer não é apenas uma caixa preta mágica, mas uma cristalização de matemática e estatística meticulosamente projetada.

1. Limitações dos métodos tradicionais e a inovação do Transformer

Antes do surgimento do Transformer, a corrente principal do processamento de linguagem natural eram as Redes Neurais Recorrentes (RNN) e sua derivação, o LSTM (Long Short-Term Memory). As RNNs são projetadas para processar dados de séries temporais, lendo o texto sequencialmente, palavra por palavra, a partir do início.

No entanto, as RNNs tinham duas fraquezas fatais:

Dificuldade em aprender dependências de longo prazo: À medida que a frase se torna mais longa, as informações das palavras inseridas no início desaparecem quando chegam ao fim (problema do desaparecimento do gradiente).
Impossibilidade de computação paralela: Como as palavras devem ser processadas sequencialmente, a computação paralela em larga escala usando GPUs é difícil, e o treinamento exige uma quantidade enorme de tempo.

O Transformer causou uma mudança de paradigma ao abandonar completamente a estrutura da RNN e usar apenas a “Attention” para capturar o contexto. Isso tornou possível processar sequências de qualquer tamanho sem perda de informação e, ao mesmo tempo, paralelizar os cálculos para maximizar o desempenho das GPUs.

2. Arquitetura geral do Transformer

Primeiro, vamos dar uma visão geral da arquitetura do Transformer. O Transformer é amplamente dividido em dois blocos: “Encoder” (Codificador) e “Decoder” (Decodificador). Tomando uma tarefa de tradução como exemplo, o Encoder converte o idioma de entrada (ex.: inglês) em uma representação vetorial matemática, e o Decoder usa essa representação vetorial para gerar o idioma de saída (ex.: japonês).

O diagrama abaixo é uma versão simplificada da estrutura interna do bloco Encoder.

graph TD A["Tokens de Entrada"] --> B["Input Embedding"] B --> C["Positional Encoding"] C --> D["Multi-Head Self-Attention"] D --> E["Add & Layer Normalization"] E --> F["Feed Forward Network"] F --> G["Add & Layer Normalization"] G --> H["Saída para a Próxima Camada"] C -.->|"Conexão Residual"| E E -.->|"Conexão Residual"| G

A partir daqui, vamos analisar passo a passo as operações matemáticas que ocorrem em cada componente.

3. Vetorização de palavras e Positional Encoding (Codificação Posicional)

Os computadores não podem entender o texto como ele é. O texto de entrada é primeiro dividido em unidades chamadas “Tokens”, e cada um é convertido em um vetor de comprimento fixo. Este é o Input Embedding.

3.1 A matemática do Input Embedding

Seja $V$ o tamanho do vocabulário e $d_{model}$ a dimensão do vetor de embedding (no artigo original, $d_{model} = 512$). Cada palavra $w_i$ é convertida em um vetor $x_i \in \mathbb{R}^{d_{model}}$ usando a matriz de embedding $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Desta forma, o texto inteiro é representado como uma matriz $X \in \mathbb{R}^{N \times d_{model}}$ (onde $N$ é o comprimento da frase).

3.2 A necessidade e as fórmulas do Positional Encoding

O Transformer não processa palavras sequencialmente como uma RNN, mas processa todas as palavras simultaneamente em paralelo. Esta é uma grande vantagem em termos de velocidade de cálculo, mas ao mesmo tempo causa o problema de perda da informação crucial sobre a “ordem das palavras”. Por exemplo, “o cachorro morde o homem” e “o homem morde o cachorro” têm o mesmo conjunto de palavras de entrada, mas os significados são completamente diferentes.

O que foi idealizado para fornecer essa informação sobre a ordem das palavras ao modelo é o Positional Encoding. O Positional Encoding $PE$ para a $i$-ésima dimensão de uma palavra na posição $pos$ é calculado usando as seguintes funções trigonométricas:

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Aqui, $pos$ é a posição da palavra ($0, 1, 2, \dots, N-1$) e $i$ é o índice da dimensão do vetor ($0, 1, \dots, d_{model}/2 - 1$).

Por que usar seno e cosseno?

À primeira vista, parecem fórmulas muito complexas e estranhas, mas há uma razão matemática profunda para isso. Ao usar funções trigonométricas, o modelo pode aprender facilmente não apenas a “posição absoluta”, mas também a diferença na “posição relativa”.

Lembre-se do teorema de adição para funções trigonométricas aprendido na matemática do ensino médio:

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

O Positional Encoding de uma posição $pos + k$ deslocada por um offset $k$ a partir de uma certa posição $pos$ pode ser expresso como uma combinação linear do Positional Encoding da posição $pos$. Em outras palavras, pode ser escrito da seguinte forma usando uma matriz $M_k$:

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

Com isso, o mecanismo de Attention pode reconhecer facilmente a distância relativa, ou seja, “o quão distantes” as palavras estão umas das outras, através do cálculo do produto escalar. Além disso, ao combinar múltiplas ondas de seno e cosseno com comprimentos de onda diferentes, há a vantagem de poder gerar vetores de posição únicos, não importa quão longa seja a frase.

A matriz de entrada final $X_{input}$ é a soma dos vetores de embedding das palavras e deste Positional Encoding.

$$ X_{input} = X + PE $$

4. A profunda matemática do Self-Attention (Mecanismo de Auto-Atenção)

Agora vamos entrar no componente mais importante do Transformer: o Self-Attention. O objetivo do Self-Attention é “calcular o grau de relacionamento entre todas as palavras na frase e atualizar o vetor de cada palavra para uma representação mais rica que leve em conta o contexto”.

Aqui, usamos a analogia de um “sistema de busca”.

Query (Q): Consulta (termo de busca). “Qual informação estou procurando agora?”
Key (K): Chave (título). “Quais informações eu tenho?”
Value (V): Valor (entidade). “Qual informação eu realmente forneço?”

4.1 Geração das matrizes $Q, K, V$

Para a matriz de entrada $X \in \mathbb{R}^{N \times d_{model}}$ (ignoraremos o tamanho do batch aqui por simplicidade), calculamos as consultas $Q$, chaves $K$ e valores $V$ multiplicando pelas matrizes de pesos treináveis $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$. (Geralmente $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Aqui, $Q, K, V$ são todas matrizes em $\mathbb{R}^{N \times d_k}$.

4.2 Cálculo do Attention Score (Produto Escalar)

Para medir o quão relacionada está a Query de cada palavra com as Keys de todas as outras palavras, calculamos o produto escalar dos vetores. Escrito como uma operação de matriz, fica da seguinte forma:

$$ \text{Scores} = Q K^T $$

Cada elemento $s_{ij}$ da matriz $\text{Scores} \in \mathbb{R}^{N \times N}$ obtida por este cálculo representa o produto escalar da Query da $i$-ésima palavra e a Key da $j$-ésima palavra, ou seja, a “força da relação”.

4.3 Dimensionamento (Scale)

Existe um problema com o cálculo da pontuação por produto escalar. Quando a dimensão do vetor $d_k$ aumenta, o valor do produto escalar pode se tornar extremamente grande ou pequeno.

Vamos provar isso matematicamente. Suponha que cada elemento de uma consulta $q \sim \mathcal{N}(0, 1)$ e cada elemento de uma chave $k \sim \mathcal{N}(0, 1)$ sigam distribuições normais padrão independentes. Calculamos a média e a variância do produto escalar $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Média: Como $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, a média da soma também é $0$. Variância: Devido à independência, a variância de $q_i k_i$ é $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Portanto, a variância de todo o produto escalar será igual à dimensão $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Se a variância se tornar grande, na função Softmax aplicada posteriormente, o gradiente para valores além do valor máximo se tornará extremamente pequeno (ocorrendo o “desaparecimento do gradiente”), e o aprendizado não progredirá. Para evitar isso, dividimos as pontuações por $\sqrt{d_k}$ (escalonamento) para manter a variância sempre em $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Transformação em probabilidades com a função Softmax

Aplicamos a função Softmax a cada linha para converter as pontuações obtidas em uma distribuição de probabilidade (pesos) cuja soma seja $1$.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

A matriz $A \in \mathbb{R}^{N \times N}$ é chamada de matriz de Attention Weight (Pesos de Atenção). Observando cada linha $i$ desta matriz, vemos expressa em valores de 0 a 1 “quanta atenção (Attention) deve ser dada a qualquer outra palavra $j$ a fim de compreender a palavra $i$”.

4.5 Soma ponderada dos Values

Finalmente, usando a matriz de Attention Weight $A$ obtida, calculamos a soma ponderada da matriz Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

A matriz $Z \in \mathbb{R}^{N \times d_v}$ gerada por esta operação é um conjunto de “representações vetoriais de palavras atualizadas considerando o contexto”. Esta é toda a estrutura do Scaled Dot-Product Attention definida no artigo.

5. Multi-Head Attention (Atenção Multi-Cabeças)

Com apenas um cálculo de Attention (single head), o contexto pode ser capturado sob apenas uma perspectiva (por exemplo, “relação gramatical”). Portanto, para capturar simultaneamente as diversas relações semânticas e sintáticas da linguagem (como “sujeito e predicado”, “pronome e seu referente”, etc.), o Multi-Head Attention foi introduzido.

O processo de geração de $Q, K, V$ e o cálculo de Attention vistos anteriormente são realizados em paralelo $h$ vezes (o número de cabeças. No artigo original, $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Aqui, $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ são matrizes de pesos treináveis dedicadas à $i$-ésima cabeça.

Os resultados produzidos por cada cabeça, $\text{head}_i \in \mathbb{R}^{N \times d_v}$, são concatenados (Concatenate) horizontalmente.

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Normalmente, isso é configurado de modo que $h \cdot d_v = d_{model}$, para que a dimensão após a concatenação volte a ser $d_{model}$, assim como na entrada. Por fim, multiplicamos esta matriz por uma matriz de pesos $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ para obter a saída final.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Entrada X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Cabeça 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Cabeça 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Cabeça h"] H1 & H2 & HN --> C["Concatenar"] C --> WO["Multiplicar por WO"] WO --> OUT["Saída Multi-Head"]

6. Feed-Forward Neural Network (FFN)

A saída do Multi-Head Attention é então inserida em uma Position-wise Feed-Forward Network (FFN). Esta é uma rede neural de duas camadas totalmente conectada aplicada “independentemente a cada posição (palavra)” da sequência.

Expresso em uma fórmula matemática, isso se parece com o seguinte:

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Aqui, $\max(0, z)$ representa a função de ativação ReLU (Rectified Linear Unit) (em modelos recentes, GELU ou SwiGLU são frequentemente utilizados).

O papel dessa rede é extremamente importante. O mecanismo de Attention aprende “as relações entre as palavras (relações espaciais e sequenciais)”, enquanto a FFN é responsável pela “transformação não-linear de características de cada vetor de palavra em si”. Normalmente, a dimensão é primeiro bastante expandida pelos pesos da primeira camada $W_1$ (por exemplo, multiplicada por 4, de $d_{model}=512$ para $d_{ff}=2048$), e depois de realizar cálculos complexos no espaço de características, ela retorna à dimensão original através dos pesos da segunda camada $W_2$. Com essa “expansão e contração de dimensões”, a expressividade do modelo aumenta drasticamente.

7. Conexão Residual (Residual Connection) e Layer Normalization (Normalização de Camada)

No deep learning, à medida que a rede se torna mais profunda, pode ocorrer o problema do desaparecimento ou da explosão dos gradientes durante o treinamento, o que impede a aprendizagem adequada. Para evitar isso, uma Conexão Residual (Residual Connection) e uma Layer Normalization (Normalização de Camada) são colocadas em torno de cada subcamada (Attention e FFN) do Transformer.

Matematicamente, a saída de uma subcamada é processada da seguinte forma:

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Conexão Residual ($x + \text{Sublayer}(x)$)

A entrada $x$ é adicionada diretamente à saída da subcamada. Com isso, os gradientes durante a retropropagação passam por um atalho (shortcut) e são transmitidos diretamente para as camadas mais superficiais, permitindo que o treinamento seja estabilizado mesmo com um aumento na profundidade das camadas.

7.2 A matemática da Layer Normalization

Layer Normalization é uma técnica para normalizar os dados, calculando a média e a variância ao longo da dimensão das características. Para uma entrada com um tamanho de batch $B$, comprimento da sequência $N$ e dimensão $d_{model}$, a normalização é feita de forma independente para cada vetor de palavra $x \in \mathbb{R}^{d_{model}}$.

Calculamos a média $\mu$ e a variância $\sigma^2$:

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

E então obtemos a saída normalizada $\hat{x}$:

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

(Onde $\epsilon$ é uma pequena constante para evitar a divisão por zero. $\gamma$ e $\beta$ são parâmetros treináveis de escala e deslocamento)

A razão pela qual se adotou a Layer Normalization em vez da Batch Normalization (normalização ao longo da dimensão do batch) é que estatísticas entre os batches tendem a ficar instáveis ao lidar com dados sequenciais de comprimentos variados, como textos. Graças à Layer Normalization, o Transformer pode alcançar um aprendizado estável, independentemente do tamanho do batch.

8. Estrutura específica do Decoder: Masked Attention e Cross-Attention

A estrutura explicada até agora diz respeito ao codificador (encoder). O bloco decodificador (decoder), que gera o texto, possui uma estrutura ligeiramente diferente.

8.1 Masked Multi-Head Attention

A função do decodificador é “prever a próxima palavra com base nas palavras passadas”. Consequentemente, olhar para “palavras futuras” durante o treinamento seria trapaça. A operação matemática para evitar isso é o Masking (Mascaramento).

À matriz de pontuações $Q K^T$, adicionamos uma matriz de máscara $M$ que define a parte triangular superior (correspondente às informações futuras) com valores extremamente pequenos, próximos de $-\infty$.

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

Quando a função Softmax é calculada, como $\exp(-\infty) = 0$, os pesos de atenção (Attention Weights) para as palavras futuras tornam-se completamente $0$. Dessa forma, é possível realizar uma geração autorregressiva que preserva a causalidade (Causality).

8.2 Encoder-Decoder Cross-Attention

A segunda subcamada no decodificador é a Cross-Attention, que faz referência à saída do codificador. Aqui, a Query $Q$ é gerada pela camada de decodificação anterior, mas as chaves $K$ e os valores $V$ são gerados a partir da saída da camada final do codificador.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

Este cálculo permite que o modelo aprenda, por exemplo em tarefas de tradução, “a qual parte da frase no idioma estrangeiro original a palavra sendo traduzida agora está fortemente associada”.

9. Complexidade computacional e a matemática das otimizações modernas

O Transformer é um modelo excelente, mas as “fraquezas” inerentes à sua estrutura matemática também existem. Considere a complexidade computacional do Self-Attention. O cálculo da matriz de pontuação $Q K^T$ envolve multiplicar uma matriz de tamanho $(N \times d_k)$ por uma de tamanho $(d_k \times N)$, então sua complexidade computacional é $O(N^2 \cdot d_{model})$.

Em outras palavras, a quantidade de cálculo e o uso de memória crescem quadraticamente em relação ao comprimento da sequência $N$. Quando as frases são curtas, isso não é um problema, mas se você tentar alimentar um LLM com um contexto vasto como o conteúdo de um livro inteiro, $N$ atinge dezenas a centenas de milhares, e o cálculo tradicional da Attention esgotará imediatamente a memória da GPU.

Para quebrar essa maldição do $O(N^2)$, várias otimizações têm sido propostas nos últimos anos com base em abordagens matemáticas e de hardware. Um exemplo representativo é o FlashAttention. FlashAttention é um algoritmo que minimiza a transferência de dados (acesso à memória) entre a hierarquia de memória da GPU (SRAM e HBM) ao realizar cálculos de Attention particionados em blocos (Tiling). Embora matematicamente produza exatamente os mesmos resultados que a Attention padrão (Exact Attention), otimizações no nível do hardware proporcionaram acelerações drásticas e reduções de memória, tornando viáveis modelos de contexto longo como o GPT-4.

Existem também muitas pesquisas ativas focadas em Sparse Attention e Linear Attention, que buscam aproximar a complexidade computacional em $O(N \log N)$ e $O(N)$.

10. Exemplo de implementação (Pseudocódigo no estilo PyTorch)

Quando traduzimos a estrutura matemática descrita até agora para um código de programação real (Python / PyTorch), percebemos que ela pode ser escrita de forma surpreendentemente simples. O código a seguir mostra o pseudocódigo para a parte central do Self-Attention.

 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


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # Formato de q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Cálculo da pontuação pelo produto escalar: Q * K^T
 # Transpondo as últimas duas dimensões para calcular o produto de matrizes
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Dimensionamento (Scaling)
 scores = scores / math.sqrt(d_k)

 # 3. Mascaramento (para o caso de Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Transformação em probabilidades pelo Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Multiplicação pela matriz Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Podemos ver intuitivamente que a fórmula matemática $Q K^T / \sqrt{d_k}$ é implementada como torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). É um aspecto muito fascinante do deep learning como a teoria matemática ganha vida em apenas algumas linhas de código com o poder de bibliotecas avançadas de otimização.

Conclusão: A forma da “inteligência” vista através da matemática

Neste artigo, desvendamos a profunda estrutura matemática que reside dentro do modelo Transformer.

O Embedding, que mapeia palavras em um espaço vetorial multidimensional, o Positional Encoding, que expressa a informação posicional ao combinar ondas trigonométricas, e o mecanismo de Self-Attention, que é o cálculo de produto escalar de matrizes nascido de uma analogia de recuperação de informação. Cada um desses componentes nada mais é do que o empilhamento de conceitos matemáticos básicos, como álgebra linear, cálculo diferencial, probabilidade e estatística.

No entanto, quando essas simples operações de matrizes são acumuladas em várias camadas e, através de bilhões a centenas de bilhões de parâmetros, padrões são extraídos de bancos de dados massivos, surge uma “forma de inteligência” capaz de compreender nossas “palavras”, fazer raciocínios lógicos e, ocasionalmente, conceber ideias criativas.

Como o título provocativo “Attention Is All You Need” sugere, a beleza dessa arquitetura - que descarta o processamento recursivo complexo e o processamento convolucional para se especializar totalmente no cálculo puro de “atenção (grau de relevância)” - encontra-se justamente na sua simplicidade matemática.

Pode ser que no futuro surjam novas arquiteturas que superem o Transformer (como a Mamba, que é um State Space Model), mas o framework matemático de “compreensão de contexto através da Attention”, pavimentado pelo Transformer, certamente ficará gravado na história da IA para sempre.

Se você tiver a oportunidade de usar LLMs como ChatGPT e Claude no futuro, tente imaginar os trilhões de multiplicações de matrizes $Q K^T$ sendo calculadas nos bastidores a cada segundo, bem como as probabilidades sendo geradas pela função Softmax. Sua resolução tecnológica aumentará, e você sem dúvida achará o mundo da IA ainda mais interessante.

Referências

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Este artigo foi escrito como um guia para aqueles que desejam aprender os fundamentos matemáticos do processamento de linguagem natural e da IA. Sinta-se à vontade para deixar suas dúvidas ou comentários na seção de discussão abaixo!

Fundamentos e Implementação da Criptografia usando o Pequeno Teorema de Fermat

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

1. Introdução: O mistério matemático que sustenta a criptografia moderna

Na sociedade digital moderna, especialmente nas comunicações via Internet, a “criptografia” tornou-se uma tecnologia fundamental indispensável. O fato de podermos navegar na web de forma segura via HTTPS em nossos navegadores, realizar transações financeiras no internet banking e trocar mensagens privadas em aplicativos de mensagens é possível devido aos protocolos criptográficos apoiados por teorias matemáticas avançadas que operam nos bastidores. Entre eles, o sistema de “criptografia de chave pública” desempenha um papel particularmente importante, e seu principal representante é a Criptografia RSA.

A segurança e a validade de muitos algoritmos criptográficos, incluindo o RSA, dependem fortemente de um teorema muito belo e poderoso descoberto pelo matemático francês do século 17, Pierre de Fermat. Esse é o Pequeno Teorema de Fermat (Fermat’s Little Theorem). Além disso, o teorema de Leonhard Euler, que generaliza isso, também desempenha um papel decisivo na teoria da criptografia.

Neste artigo, explicaremos detalhadamente desde o básico como a descoberta do Pequeno Teorema de Fermat, na matemática pura, é aplicada às tecnologias de criptografia práticas modernas, em particular ao “teste de primalidade” e à “criptografia RSA”. Este será um guia técnico muito detalhado que cobre provas matemáticas, os mecanismos de criptografia e descriptografia, e implementações de algoritmos específicos em C++ e Python.

2. Fundamentos de Congruências e Aritmética Modular

Para entender o Pequeno Teorema de Fermat, primeiro precisamos nos familiarizar com o conceito matemático de “aritmética modular (congruências)”. A aritmética modular é um sistema de cálculo que foca no “resto” quando dividido por um número fixo (chamado de módulo). Por ser um cálculo parecido com o mostrador de um relógio (que dá uma volta em 12 horas), também é chamada de “matemática do relógio”.

Quando o resto da divisão dos inteiros $a$ e $b$ por um inteiro positivo $n$ é igual, matematicamente, descrevemos da seguinte forma:

$$ a \equiv b \pmod n $$

Isso é lido como “$a$ e $b$ são congruentes módulo $n$”. Por exemplo, o resto da divisão de 17 por 5 é 2, e o resto da divisão de 12 por 5 também é 2. Portanto, podemos escrever:

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

Na aritmética modular, as quatro operações aritméticas normais (adição, subtração e multiplicação) valem como são:

Adição: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a + c \equiv b + d \pmod n$
Subtração: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a - c \equiv b - d \pmod n$
Multiplicação: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a \times c \equiv b \times d \pmod n$
Exponenciação: Se $a \equiv b \pmod n$, então para qualquer número natural $k$, $a^k \equiv b^k \pmod n$

No entanto, é necessário ter cuidado com a divisão. Em geral, o fato de que $a \times c \equiv b \times c \pmod n$ não significa que podemos dividir ambos os lados por $c$ para obter $a \equiv b \pmod n$. Isso só é verdadeiro se $c$ e $n$ forem coprimos (o máximo divisor comum for 1). Esse conceito de “inverso modular” torna-se extremamente importante na geração de chaves da criptografia RSA descrita mais adiante.

3. Fundamentação Matemática e Prova do Pequeno Teorema de Fermat

Agora que entendemos os fundamentos da aritmética modular, vamos analisar o assunto principal: o Pequeno Teorema de Fermat.

3.1 Definição do Teorema

O Pequeno Teorema de Fermat é formulado da seguinte maneira:

Pequeno Teorema de Fermat (Fermat’s Little Theorem) Seja $p$ um número primo e $a$ um número inteiro que não seja um múltiplo de $p$ (ou seja, $a$ e $p$ são coprimos). Então, a seguinte congruência é válida:
$$ a^{p-1} \equiv 1 \pmod p $$

Também é comum expressá-lo de uma forma que seja válida para todos os inteiros $a$, removendo a condição “se $a$ não for múltiplo de $p$”. Nesse caso, multiplicando ambos os lados por $a$, temos:

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

3.2 Confirmação com Exemplos Específicos

Vamos confirmar se o teorema é realmente válido usando números específicos. Seja o número primo $p = 5$. Então $p-1 = 4$. Escolheremos um número inteiro $a$ que não seja um múltiplo de $p$.

Para $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ com resto $1$. Portanto, $16 \equiv 1 \pmod 5$. (Válido)
Para $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ com resto $1$. Portanto, $81 \equiv 1 \pmod 5$. (Válido)
Para $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ com resto $1$. Portanto, $256 \equiv 1 \pmod 5$. (Válido)

Como podemos ver, qualquer $a$ que escolhermos (desde que não seja um múltiplo de 5), o resto após elevá-lo à quarta potência e dividi-lo por 5 será sempre 1. Parece magia, mas isso se origina das belas propriedades que os números primos possuem.

3.3 Prova Matemática do Teorema

Por que isso acontece? Aqui apresentamos uma prova elegante usando conjuntos de classes de resíduos.

Considere o conjunto $S = \{1, 2, 3, \dots, p-1\}$. Estes são os representantes dos números inteiros cujos restos da divisão por $p$ são de $1$ a $p-1$. Agora, considere um novo conjunto $T$, formado pela multiplicação de cada elemento por um inteiro $a$, coprimo com $p$.

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

Vamos considerar o resto de cada elemento desse conjunto $T$ quando dividido por $p$. Surpreendentemente, esses restos, embora a ordem possa mudar, coincidem perfeitamente com o conjunto de elementos do conjunto original $S$. Por que:

Nenhum elemento de $T$ será múltiplo de $p$ (porque nem $a$ nem os elementos originais são múltiplos de $p$).
Não existem dois elementos diferentes em $T$ que sejam congruentes módulo $p$. Se houvesse $ia \equiv ja \pmod p$ ($i \neq j$), já que $a$ e $p$ são coprimos, poderíamos dividir por $a$ e obter $i \equiv j \pmod p$, o que é uma contradição.

Portanto, o produto de todos os elementos de $S$ e o produto de todos os elementos de $T$ são congruentes módulo $p$.

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

Organizando o lado esquerdo, como temos $p-1$ fatores $a$, obtemos:

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

Como $(p-1)!$ e $p$ são coprimos, podemos dividir ambos os lados por $(p-1)!$, o que nos leva finalmente ao seguinte teorema:

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

Esta é a prova do Pequeno Teorema de Fermat.

4. A Função Totiente de Euler e o Teorema de Euler

O Pequeno Teorema de Fermat é um teorema sobre um “número primo $p$”, mas quem o generalizou para “qualquer inteiro positivo $n$” foi Leonhard Euler. Essa extensão é essencial para compreender a criptografia RSA.

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

A função totiente de Euler (ou função $\phi$ de Euler) $\phi(n)$ é uma função que representa “a quantidade de inteiros de $1$ a $n$ que são coprimos com $n$”.

Para um número primo $p$, como todos os inteiros de $1$ a $p-1$ são coprimos com $p$, temos $\phi(p) = p - 1$.
Para dois números primos distintos $p$ e $q$, o valor de $\phi(n)$ para o seu produto $n = p \times q$ pode ser calculado com uma fórmula muito simples: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Esta propriedade é a lógica central na geração de chaves da criptografia RSA.

4.2 Teorema de Euler

Euler generalizou o Pequeno Teorema de Fermat da seguinte maneira:

Teorema de Euler (Euler’s Theorem) Para qualquer inteiro positivo $n$ e um inteiro $a$ coprimo com ele, é válido que:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Se $n$ for um número primo $p$, então $\phi(p) = p - 1$, o que o torna exatamente o Pequeno Teorema de Fermat ($a^{p-1} \equiv 1 \pmod p$). Em outras palavras, o Pequeno Teorema de Fermat não passa de um caso especial do Teorema de Euler.

5. Encontrando Números Primos Gigantescos: O Teste de Primalidade de Fermat

Na tecnologia criptográfica (como a criptografia RSA e a troca de chaves Diffie-Hellman), é necessário encontrar “números primos gigantescos” de centenas de dígitos em alta velocidade. No entanto, para testar se um número gigante $N$ é primo através da “divisão por tentativa” (testando a divisibilidade por todos os números de $2$ a $\sqrt{N}$), levaria tanto tempo quanto a idade do universo.

Aqui entra o Teste de Primalidade de Fermat (Fermat Primality Test), um “teste de primalidade probabilístico” que usa o Pequeno Teorema de Fermat.

5.1 O que é um Teste de Primalidade Probabilístico?

De acordo com o Pequeno Teorema de Fermat, se $p$ for um número primo, então, para qualquer $a$ ($1 < a < p$), $a^{p-1} \equiv 1 \pmod p$ é sempre válido. Tomando a contrapositiva: “Se houver algum $a$ para o qual $a^{p-1} \not\equiv 1 \pmod p$, então $p$ absolutamente não é um número primo (é um número composto)”.

Portanto, se quisermos testar se $N$ é um número primo, escolhemos aleatoriamente alguns valores para $a$, calculamos $a^{N-1} \pmod N$ e verificamos se o resultado é $1$. Se obtivermos uma resposta diferente de $1$ mesmo que seja apenas uma vez, concluímos que $N$ é um número composto. Se o resultado for sempre $1$, independentemente de quantas vezes testarmos, podemos julgar com alta probabilidade que $N$ “provavelmente é primo”.

5.2 Explicação do Algoritmo e Fluxograma

O algoritmo do teste de Fermat é o seguinte.

flowchart TD Start["Início"] --> Input["Inserir o número a testar p e o número de testes k"] Input --> LoopStart["Loop de i = 0 até k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Sim" --> RandomA["Escolher um inteiro aleatório a no intervalo 1 < a < p-1"] RandomA --> Calc["Calcular a exponenciação modular a^(p-1) mod p"] Calc --> CheckPrime{"O resultado é 1 ?"} CheckPrime -- "Não" --> ReturnComposite["p é um número composto (Definitivo)"] CheckPrime -- "Sim" --> Increment["Incrementar i"] Increment --> Condition Condition -- "Não" --> ReturnPrime["p é provavelmente primo (Probabilístico)"] ReturnComposite --> End["Fim"] ReturnPrime --> End

5.3 A Armadilha dos Números de Carmichael (Pseudoprimos)

O teste de Fermat é extremamente rápido, mas tem uma desvantagem séria. Existem números maldosos que, apesar de serem compostos, satisfazem $a^{N-1} \equiv 1 \pmod N$ para todos os valores de $a$. Estes são chamados de Números de Carmichael (Carmichael numbers). O menor número de Carmichael é $561$ ($3 \times 11 \times 17$).

Devido à existência dos números de Carmichael, não se pode realizar um teste de primalidade absoluto usando apenas o teste puro de Fermat. Por esta razão, em sistemas criptográficos reais (como o OpenSSL), o Teste de Primalidade de Miller-Rabin, que é um aprimoramento do teste de Fermat, é usado como padrão. O teste de Miller-Rabin consegue detectar os números de Carmichael, reduzindo a probabilidade de falso julgamento praticamente a zero.

5.4 Exponenciação Modular Rápida (Método de Exponenciação Binária)

No algoritmo de teste de primalidade, precisamos calcular $a^{N-1} \pmod N$, mas se $N$ for enorme, $a^{N-1}$ terá uma quantidade astronômica de dígitos e não caberá na memória do computador. O que resolve esse problema é a Exponenciação Binária (Exponentiation by Squaring) ou exponenciação modular. Ao aplicar o módulo (mod N) a cada etapa do cálculo, o valor é mantido sempre inferior a $N$, permitindo um cálculo muito rápido (complexidade $O(\log N)$).

6. Implementação do Teste de Primalidade e Exponenciação Modular

Agora, vamos implementar o teste de primalidade de Fermat e o método de exponenciação binária em C++ e Python.

6.1 Implementação em C++

Em C++, os tipos de inteiros padrão tendem a transbordar, exigindo bibliotecas de inteiros de precisão arbitrária (como GMP) para lidar com números enormes, mas aqui mostramos uma implementação dentro do limite de um inteiro de 64 bits (unsigned long long) para entender o algoritmo.

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


#include <iostream>
#include <random>

using namespace std;

// Exponenciação modular rápida (a^b mod m) - Método de exponenciação binária
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Se o bit menos significativo de b for 1, multiplica o resultado por a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Extensão para 128 bits para evitar transbordamento
 }
 // Eleva a ao quadrado
 a = (__int128)a * a % m;
 // Desloca b para a direita (divide por 2)
 b /= 2;
 }
 return result;
}

// Teste de primalidade de Fermat
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

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

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Se a^(p-1) mod p não for 1, é um número composto
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Provavelmente primo
}

int main() {
 unsigned long long num = 1000000007; // Número primo conhecido
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Implementação em Python

O tipo inteiro padrão do Python suporta precisão arbitrária nativamente, de modo que não há necessidade de se preocupar com estouro de dígitos. Além disso, a função interna do Python pow(a, b, m) usa internamente o método de exponenciação binária, tornando-a muito rápida.

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


import random

def fermat_is_prime(p, iterations=5):
 """
 Teste de primalidade probabilístico usando o Teste de Primalidade de Fermat
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Escolhe um número aleatório a entre 2 e p-2
 a = random.randint(2, p - 2)
 # Calcula a^(p-1) mod p. A função interna pow é rápida.
 if pow(a, p - 1, p) != 1:
 return False # Definitivamente composto

 return True # Provavelmente primo

# Teste
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} é provavelmente primo.")
else:
 print(f"{number_to_test} é composto.")

7. Aplicação na Criptografia RSA: Onde Fermat e Euler dão Frutos

A maior aplicação do Pequeno Teorema de Fermat (e do Teorema de Euler) é a Criptografia RSA, desenvolvida por Rivest, Shamir e Adleman em 1977. A criptografia RSA é um sistema revolucionário de “criptografia de chave pública”, que consegue um mecanismo onde a chave para criptografar (a chave pública) é revelada a todo o mundo, enquanto a chave para descriptografar (a chave privada) é conhecida apenas pelo destinatário pretendido.

Essa assimetria é baseada na segurança computacional proporcionada pelo fato de que “a fatoração de um número composto gigantesco é extremamente difícil”.

7.1 Como Funciona a Criptografia RSA (Geração de Chaves, Criptografia, Descriptografia)

Vamos ver o fluxo geral de comunicação da criptografia RSA com um diagrama de sequência Mermaid.

sequenceDiagram participant Alice["Alice (Destinatário)"] participant Bob["Bob (Remetente)"] Alice->>Alice: "Gera os primos gigantescos p e q" Alice->>Alice: "Calcula N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Calcula a chave pública e e a chave privada d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Envia a chave pública (N, e)" Note over Bob: "Prepara o texto simples M (M < N)" Bob->>Bob: "Calcula o texto cifrado C = M^e mod N" Bob->>Alice: "Envia o texto cifrado C" Alice->>Alice: "Calcula o texto simples M = C^d mod N para descriptografar"

Abaixo, explicaremos os passos matemáticos detalhados.

Passo 1: Geração de Chaves (Tarefa da destinatária Alice)

Gera dois números primos gigantescos aleatórios $p$ e $q$ (o método de teste de primalidade descrito acima é usado aqui).
Calcula o seu produto $N = p \times q$. Este $N$ torna-se público.
Usando a função totiente de Euler, calcula $\phi(N) = (p-1)(q-1)$.
Escolhe um número inteiro $e$ (expoente público) que seja coprimo com $\phi(N)$ (geralmente $e = 65537$ é usado).
Calcula o inverso modular $d$ (expoente privado) de $e$. Ou seja, encontra $d$ que satisfaça o seguinte: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Para esse cálculo, o Algoritmo de Euclides Estendido é usado.

Com isso, a chave pública é $(N, e)$ e a chave privada é $(N, d)$. (Eles descartam imediatamente ou ocultam estritamente $p, q, \phi(N)$).

Passo 2: Criptografia (Tarefa do remetente Bob)

Suponha que Bob queira enviar a mensagem $M$ para Alice ($M$ é uma representação numérica de caracteres, onde $0 \le M < N$). Bob usa a chave pública de Alice $(N, e)$ para realizar o seguinte cálculo e criar o texto cifrado $C$.

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

Este $C$ é então enviado para Alice pela rede.

Passo 3: Descriptografia (Tarefa da destinatária Alice)

Ao receber o texto cifrado $C$, Alice realiza o seguinte cálculo usando a chave privada $d$ que apenas ela conhece.

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

Surpreendentemente, o resultado desse cálculo, $M'$, é exatamente igual à mensagem original $M$.

7.2 Por que pode ser Descriptografado? (Prova Matemática)

É aqui que o Pequeno Teorema de Fermat (Teorema de Euler) mostra seu verdadeiro valor. Por que $C^d \pmod N$ retorna a $M$?

Vamos expandir a equação de descriptografia. Como $C \equiv M^e \pmod N$,

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

No passo de geração da chave, $d$ foi escolhido para que $e \cdot d \equiv 1 \pmod{\phi(N)}$. Isso significa que existe um número inteiro $k$ tal que:

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

Substituindo isso na equação acima:

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

Aqui, entra o Teorema de Euler ($M^{\phi(N)} \equiv 1 \pmod N$). (Rigorosamente, $M$ e $N$ precisam ser coprimos, mas em RSA, a probabilidade de que $M$ e $N$ não sejam coprimos é astronomicamente baixa, e pelo Teorema Chinês do Resto, pode-se provar que é válido mesmo se não forem coprimos).

Aplicando o Teorema de Euler, como $M^{\phi(N)} \equiv 1$, temos:

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

$M$ foi perfeitamente restaurado! As propriedades dos números que Fermat e Euler descobriram há centenas de anos garantem perfeitamente a confidencialidade das comunicações digitais modernas.

8. Implementação da Criptografia RSA de Brinquedo (Python)

Uma vez que é difícil ter uma noção de como isso funciona baseando-se apenas na teoria, vamos usar o Python para implementar o processo de geração de chaves, criptografia e descriptografia da criptografia RSA na prática. Esta é uma “implementação de brinquedo” educacional, mas a matemática subjacente é exatamente a mesma.

O “Algoritmo de Euclides Estendido” para encontrar o inverso modular $d$ também será incluído na implementação.

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


import random

# Encontrar o máximo divisor comum
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Algoritmo de Euclides Estendido (encontra x e y para ax + by = gcd(a,b))
# Usado para encontrar d para e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('O inverso não existe')
 else:
 return x % phi

# Função de geração de primos (Versão simples: gera números primos pequenos)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Substitui o teste de Fermat acima por um teste simplificado
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Geração de par de chaves RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Evita que p e q sejam iguais
 while p == q:
 q = generate_prime(bits)

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

 # e costuma usar um número primo como 65537, mas vamos escolher aleatoriamente aqui
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Cálculo da chave privada d
 d = mod_inverse(e, phi)

 # Chave pública (e, n), chave privada (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Calcula plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Calcula cipher^d mod n e reverte para um caractere
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Exemplo de execução
if __name__ == '__main__':
 print("--- Implementação da Criptografia RSA de Brinquedo ---")
 public_key, private_key = generate_keypair(bits=12) # Usa um número primo de 12 bits

 print(f"Chave pública (e, n): {public_key}")
 print(f"Chave privada (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nMensagem original: {message}")

 # Criptografia
 encrypted_msg = encrypt(public_key, message)
 print(f"Texto cifrado: {encrypted_msg}")

 # Descriptografia
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Mensagem descriptografada: {decrypted_msg}")

Quando você executa este código, você pode confirmar como a matriz de caracteres é convertida em um array de números estranhos (texto cifrado), e como isso é restaurado perfeitamente para a string original através da chave privada.

9. Conclusão: A Intersecção entre a Beleza da Matemática e a Praticidade

Quando Pierre de Fermat descobriu este “pequeno teorema” no século 17, ninguém pensou que isso pudesse ser útil de alguma forma. O próprio Fermat conduziu suas pesquisas em teoria dos números com curiosidade puramente matemática.

No entanto, nos anos 1970, cerca de 300 anos depois, nos primórdios das redes de computadores, o teorema de Fermat fez um retorno dramático como uma tecnologia de criptografia essencial para estabelecer protocolos de comunicação seguros. A tecnologia do teste de primalidade baseada no Pequeno Teorema de Fermat e a Criptografia RSA, com base no Teorema de Euler, sustentam literalmente a infraestrutura moderna da internet.

Até mesmo a mensagem no LINE que enviamos casualmente todos os dias e nossas compras na Amazon, estão todas dançando no topo desta simples e bela fórmula: $a^{p-1} \equiv 1 \pmod p$. O Pequeno Teorema de Fermat nos ensina que, não importa o quão abstrata seja a matemática, o momento em que ela for útil para a humanidade sem dúvida chegará algum dia.

Ao aprender programação e teoria criptográfica, compreender a estrutura matemática em seus fundamentos será uma grande arma para o profundo entendimento do comportamento das bibliotecas fornecidas como caixas-pretas e para o design de sistemas mais seguros.

A intuição matemática da criptografia baseada em reticulados (Lattice-based cryptography)

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

1. Introdução: O alvorecer da Criptografia Pós-Quântica (PQC) e a ascensão da criptografia baseada em reticulados

A infraestrutura digital da sociedade moderna é sustentada por tecnologias de criptografia de chave pública, como a criptografia RSA e a Criptografia de Curva Elíptica (ECC). Esses métodos criptográficos baseiam sua segurança na dificuldade matemática de problemas como o “Problema de Fatoração de Inteiros” e o “Problema do Logaritmo Discreto”, que se acredita não poderem ser resolvidos eficientemente (exigindo tempo exponencial) pelos computadores clássicos convencionais.

No entanto, o “Algoritmo de Shor”, publicado por Peter Shor em 1994, enviou ondas de choque através do mundo da criptografia. Este algoritmo provou matematicamente que, uma vez realizados computadores quânticos de grande escala, problemas de fatoração de inteiros e logaritmos discretos serão resolvidos em tempo polinomial. Isso significa que a criptografia de chave pública amplamente utilizada hoje se tornará completamente decifrável no futuro.

Para combater essa “Ameaça Quântica (Quantum Threat)”, a pesquisa em novos métodos criptográficos que sejam difíceis de quebrar, mesmo usando computadores quânticos, tornou-se uma questão urgente. Este é o campo conhecido como “Criptografia Pós-Quântica (Post-Quantum Cryptography: PQC)” ou “Criptografia resistente a quantum”.

Existem vários candidatos fortes para PQC. Estes incluem criptografia baseada em hash, criptografia baseada em código, criptografia polinomial multivariada e criptografia baseada em isogenia. Entre eles, o que atualmente atrai mais atenção e é fundamental para o processo de padronização PQC do NIST (Instituto Nacional de Padrões e Tecnologia dos EUA) é a “Criptografia baseada em reticulados (Lattice-based cryptography)”. Em comparação com outros métodos, a criptografia baseada em reticulados possui velocidades de criptografia e descriptografia extremamente rápidas e exibe uma característica notável em sua prova de segurança: uma redução da “complexidade do pior caso (Worst-case complexity)” para a “complexidade do caso médio (Average-case complexity)”, que é extremamente poderosa na teoria criptográfica.

Neste artigo, começaremos pela definição matemática fundamental de um “Reticulado (Lattice)”, que é a base da criptografia baseada em reticulados, e explicaremos profundamente problemas difíceis em reticulados como SVP (Problema do Vetor Mais Curto) e CVP (Problema do Vetor Mais Próximo), e o núcleo da criptografia de reticulados moderna, o “Problema LWE (Learning With Errors)”, usando fórmulas, intuição geométrica e exemplos numéricos concretos.

2. Definição Matemática e Intuição Geométrica do Reticulado (Lattice)

2.1 Espaço Vetorial e Reticulados

Em matemática, um “Reticulado (Lattice)” é um conjunto de pontos discretos dispostos regularmente em um espaço vetorial real de dimensão $n$, $\mathbb{R}^n$. É semelhante a um espaço vetorial (Vector Space) aprendido em álgebra linear, mas há uma diferença crucial. Enquanto um espaço vetorial é um espaço contínuo representado por combinações lineares com “coeficientes reais” dos vetores de base, um reticulado é um espaço discreto representado por combinações lineares com “coeficientes inteiros” dos vetores de base.

Vamos dar uma definição matemática rigorosa. Considere $n$ vetores linearmente independentes ($n \le m$) $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ em um espaço vetorial real de dimensão $m$, $\mathbb{R}^m$. Considere uma matriz cujos vetores coluna são esses vetores: $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. Esta $B$ é chamada de “Base (Basis)” do reticulado.

O reticulado $\mathcal{L}(B)$ gerado por esta base $B$ é definido da seguinte forma:

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

O ponto importante aqui é que os coeficientes $x_i$ são restritos a inteiros $\mathbb{Z}$, e não a números reais $\mathbb{R}$. Isso forma um “conjunto de pontos discretos” semelhante a cruzamentos espaçados uniformemente, em vez dos infinitos pontos contínuos no espaço.

2.2 Imagem Geométrica

Vamos considerar um exemplo em um plano bidimensional $\mathbb{R}^2$. Se escolhermos $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ e $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ como vetores de base, o reticulado gerado por eles será o conjunto de todas as coordenadas inteiras $(x, y) \in \mathbb{Z}^2$ no plano cartesiano. Este é o “reticulado quadrado” mais simples.

No entanto, reticulados nem sempre são ortogonais. Por exemplo, considerando a base $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ e $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, os pontos gerados serão como as interseções de uma malha distorcida diagonalmente.

2.3 Não Unicidade da Base e Transformação Unimodular

Há uma propriedade importante relacionada ao núcleo da segurança da criptografia baseada em reticulados. É que “existem infinitas bases que geram o mesmo reticulado”.

Por exemplo, a base anterior $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ que gera o reticulado $\mathbb{Z}^2$ também gerará exatamente o mesmo reticulado $\mathbb{Z}^2$ se usarmos a base $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$.

A condição necessária e suficiente para uma certa base $B$ e outra base $B'$ gerarem o mesmo reticulado é que exista uma matriz com componentes inteiros $U \in \mathbb{Z}^{n \times n}$ tal que seu determinante seja $\det(U) = \pm 1$, e possa ser expressa como:

$$ B' = B U $$

Tal matriz $U$ é chamada de “matriz unimodular (Unimodular matrix)”.

A ideia básica em aplicações criptográficas é usar uma “boa base (uma base próxima de ser ortogonal, consistindo de vetores curtos)” como chave privada, e uma “base ruim (uma base consistindo de vetores extremamente oblíquos entre si e muito longos)” como chave pública. Calcular uma boa base a partir de uma base ruim torna-se extremamente difícil à medida que a dimensão aumenta. Esta é a intuição básica da criptografia baseada em reticulados.

3. Problemas Computacionalmente Difíceis em Reticulados

A segurança da criptografia baseada em reticulados depende da dificuldade de resolver certos problemas matemáticos sobre reticulados. Aqui, introduziremos os dois problemas mais fundamentais e famosos.

3.1 Problema do Vetor Mais Curto (Shortest Vector Problem: SVP)

SVP é o problema mais clássico e famoso na teoria dos reticulados.

Definição (SVP): Dada qualquer base de reticulado $B$, encontre o vetor não nulo $\mathbf{v}$ pertencente ao reticulado $\mathcal{L}(B)$ cuja norma euclidiana (comprimento) seja mínima.

Expressando em fórmula, é o problema de encontrar $\mathbf{v}$ tal que $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Este comprimento mínimo é denotado como $\lambda_1(\mathcal{L})$ e é chamado de “Primeiro mínimo sucessivo (First successive minimum)” do reticulado.

Em dimensões baixas, como 2D ou 3D, você pode desenhar uma figura e encontrar visualmente o vetor mais curto. Alternativamente, algoritmos de redução de base de Gauss podem resolvê-lo eficientemente. No entanto, sabe-se que em altas dimensões (por exemplo, dimensão $n$ na casa das centenas a milhares), resolver o SVP de forma exata é NP-difícil.

Em criptografia do mundo real, em vez do vetor mais curto exato, é usado o SVP aproximado ($\gamma$-SVP) para encontrar um “vetor aproximadamente curto”. Se o fator de aproximação $\gamma$ for de tamanho polinomial, este problema ainda é considerado extremamente difícil.

3.2 Problema do Vetor Mais Próximo (Closest Vector Problem: CVP)

CVP também é um problema extremamente importante na criptografia baseada em reticulados.

Definição (CVP): Dada qualquer base de reticulado $B$ e qualquer vetor alvo no espaço $\mathbf{t} \in \mathbb{R}^m$ (não necessariamente um ponto do reticulado), encontre o ponto do reticulado $\mathbf{v} \in \mathcal{L}(B)$ que seja o mais próximo de $\mathbf{t}$.

Expressando em fórmula, é o problema de procurar o ponto do reticulado $\mathbf{v}$ que resulta em $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

O CVP também é NP-difícil em altas dimensões, semelhante ao SVP. Do ponto de vista das aplicações criptográficas, o problema LWE, descrito posteriormente, está intimamente relacionado a uma variante especial do CVP (Bounded Distance Decoding: BDD).

3.3 Por que não pode ser resolvido em altas dimensões? (Os Limites do LLL e BKZ)

Um algoritmo famoso para resolver problemas de reticulados em altas dimensões é o algoritmo LLL (algoritmo de Lenstra-Lenstra-Lovász). O algoritmo LLL opera em tempo polinomial e pode reduzir a base do reticulado a uma “boa base” em certa medida. No entanto, o vetor mais curto encontrado pelo algoritmo LLL tem um fator de aproximação exponencial ($2^{\mathcal{O}(n)}$) em relação ao comprimento do vetor mais curto verdadeiro, portanto, não chega ao ponto de quebrar a segurança criptográfica.

Usar algoritmos de redução de base mais poderosos como o algoritmo BKZ (Block Korkine-Zolotarev), que é uma melhoria do LLL, permite encontrar vetores mais curtos, mas seu tempo de computação aumenta exponencialmente em relação ao tamanho do bloco. Na criptografia baseada em reticulados, parâmetros seguros (como o tamanho da dimensão $n$) são determinados estimando o tempo de execução deste algoritmo BKZ. Nos parâmetros padrão atuais da PQC, são escolhidos valores entre 500 e 1000 ou mais para a dimensão $n$, e estima-se que levaria mais tempo do que a idade do universo para decifrá-los, mesmo com supercomputadores ou computadores quânticos futuros.

4. Formulação Matemática do Problema LWE (Learning With Errors)

A maior parte da criptografia moderna baseada em reticulados é baseada no “Problema LWE (Learning With Errors)”, proposto por Oded Regev em 2005. A beleza do problema LWE reside na simplicidade de sua formulação e em ter uma prova matemática poderosa: a “redução da complexidade do pior caso para a complexidade do caso médio”.

4.1 Equações lineares simultâneas sem ruído

Para entender o problema LWE, vamos primeiro considerar equações lineares simultâneas simples sem ruído. Suponha que haja um vetor secreto desconhecido $\mathbf{s} \in \mathbb{Z}_q^n$ (cada componente é um número inteiro de $0$ a $q-1$). Aqui, $q$ é considerado um número primo.

Escolhemos vetores de coeficientes aleatórios $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$, e calculamos seu produto escalar com o vetor secreto $\mathbf{s}$ módulo $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Se nos derem um número suficiente (pelo menos $n$) de pares $(\mathbf{a}_i, b_i)$, podemos restaurar facilmente o vetor secreto $\mathbf{s}$ usando a “Eliminação Gaussiana (Gaussian elimination)” em álgebra linear. Este é um problema que pode ser resolvido facilmente em tempo polinomial.

4.2 Definição do problema LWE: Adicionando Ruído

Então, o que acontece se adicionarmos um pouco de “ruído (erro)” a este problema? Esta é a essência do problema LWE.

Para o vetor secreto desconhecido $\mathbf{s} \in \mathbb{Z}_q^n$, adicionamos um pequeno erro $e_i \in \mathbb{Z}_q$ ao resultado de cada equação. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Aqui, $e_i$ é um número inteiro pequeno com média 0 e desvio padrão relativamente pequeno (por exemplo, retirado de uma distribuição Gaussiana discreta, como uma distribuição normal). A informação fornecida é uma lista de pares do vetor aleatório $\mathbf{a}_i$ e $b_i$ calculado adicionando o erro. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Expressar isso em forma de matriz o torna muito claro. Usando uma matriz aleatória $A \in \mathbb{Z}_q^{m \times n}$, um vetor secreto $\mathbf{s} \in \mathbb{Z}_q^n$, e um vetor de erro $\mathbf{e} \in \mathbb{Z}_q^m$,

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

pode ser escrito. Apenas $A$ e $\mathbf{b}$ são fornecidos. Encontrar $\mathbf{s}$ a partir disso é o “Problema de busca LWE (Search LWE problem)”.

Como o erro $e_i$ está incluído, ao tentar usar a eliminação gaussiana, o erro será amplificado exponencialmente durante o processo de adição e subtração de equações, tornando impossível chegar à resposta correta. À primeira vista, parecem equações lineares simultâneas simples, mas apenas adicionando esse pequeno ruído, o nível de dificuldade do problema salta para um nível NP-difícil.

4.3 Problema LWE de decisão (Decision LWE)

O que é frequentemente usado em provas na teoria criptográfica é uma variação do problema de busca LWE chamado de “Problema LWE de decisão (Decision LWE problem)”.

O problema de decisão LWE é o problema de determinar de qual de duas distribuições uma lista de amostras fornecida se origina.

Distribuição LWE: Intencionalmente calculada $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
Distribuição aleatória uniforme: $(A, \mathbf{u})$ que consiste em uma matriz completamente escolhida aleatoriamente $A$ e vetor $\mathbf{u}$

Surpreendentemente, se os parâmetros do problema LWE forem escolhidos de forma apropriada, pares de dados da distribuição LWE tornam-se “computacionalmente indistinguíveis (Computationally Indistinguishable)” de pares de dados completamente aleatórios. Esta propriedade é a base pela qual os cifradores baseados em LWE podem gerar “textos cifrados indistinguíveis de números aleatórios”.

4.4 Redução da complexidade do pior caso para a complexidade do caso médio (Teorema de Regev)

A maior conquista de Oded Regev foi ter vinculado matematicamente a dificuldade deste problema LWE à dificuldade dos problemas de reticulados (SVP e CVP) mencionados acima.

Ele usou a redução quântica (Quantum reduction) para provar que “Se existe um algoritmo de tempo polinomial que pode resolver o problema LWE na média (para $A$ e $\mathbf{e}$ escolhidos aleatoriamente), então existe um algoritmo quântico de tempo polinomial que pode resolver o Gap-SVP no pior caso (o caso mais difícil) para qualquer reticulado”. (Mais tarde, Peikert e outros também mostraram a redução clássica).

Esta é uma propriedade dos sonhos na teoria criptográfica. Porque dissipa a preocupação de que “a criptografia possa ser quebrada porque por acaso escolhemos uma chave fraca (uma parte do caso médio)” e nos dá a poderosa garantia de que “Se o LWE médio puder ser resolvido, todos os problemas difíceis do reticulado poderão ser resolvidos (portanto, o LWE é absolutamente difícil)”.

graph TD A["Problemas de Reticulado de Pior Caso (Gap-SVP, SIVP)"] -->|Redução Quântica/Clássica| B["Problema LWE de Caso Médio"] B -->|Construção Criptográfica| C["Sistemas Criptográficos baseados em LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Construção do Cifrador de Chave Pública usando LWE (Cifrador Regev)

Agora que entendemos a dificuldade do problema LWE, vamos ver a criptografia de chave pública básica proposta por Oded Regev para ver como ela é usada para criptografia e descriptografia. Aqui, explicaremos o mecanismo mais básico para criptografar uma mensagem de 1 bit $M \in \{0, 1\}$.

5.1 Geração de chaves (Key Generation)

Determine o módulo primo $q$, a dimensão $n$, e o número de equações $m$ ($m > n \log q$) como parâmetros do sistema.
Como uma chave privada, escolha um vetor $\mathbf{s} \in \mathbb{Z}_q^n$ aleatoriamente.
Gere uma matriz aleatória $A \in \mathbb{Z}_q^{m \times n}$.
Escolha um vetor de erro pequeno $\mathbf{e} \in \mathbb{Z}_q^m$ a partir de uma distribuição de erro como a distribuição gaussiana discreta.
Calcule o vetor $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
A chave pública (Public Key) será $(A, \mathbf{b})$.
A chave privada (Secret Key) será $\mathbf{s}$.

A chave pública é exatamente a “instância do problema LWE” em si. Uma vez que encontrar a chave privada $\mathbf{s}$ a partir da chave pública $(A, \mathbf{b})$ é equivalente a resolver o problema de busca LWE, a segurança é garantida.

5.2 Criptografia (Encryption)

Alice usa a chave pública de Bob $(A, \mathbf{b})$ para criptografar a mensagem de 1 bit $M \in \{0, 1\}$.

Escolha um vetor binário aleatório (composto de zeros ou uns) $\mathbf{r} \in \{0, 1\}^m$.
Como a primeira metade do texto cifrado, calcule o vetor $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ é a matriz transposta de $A$. Em outras palavras, está somando as linhas de $A$ onde os componentes de $\mathbf{r}$ são 1).
Como a segunda metade do texto cifrado, calcule o escalar $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Se a mensagem $M$ for 0, nada é adicionado; se for $1$, é adicionado o valor exatamente da metade de $q$, $\lfloor \frac{q}{2} \rfloor$).
O texto cifrado (Ciphertext) será $(\mathbf{u}, v)$.

O significado intuitivo da criptografia é pegar a “soma de um subconjunto aleatório” para a matriz de chave pública $A$ e o vetor $\mathbf{b}$. Devido à dificuldade do problema LWE de decisão, esse texto cifrado $(\mathbf{u}, v)$ parece indistinguível de um vetor completamente aleatório e um número aleatório uniforme (Segurança semântica: Semantic Security).

flowchart LR M["Mensagem M em {0,1}"] --> Enc PK["Chave Pública (A, b)"] --> Enc r["Vetor binário aleatório r"] --> Enc subgraph Enc ["Processo de Criptografia"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Texto Cifrado (u, v)"]

5.3 Descriptografia (Decryption)

Bob descriptografa o texto cifrado $(\mathbf{u}, v)$ usando a chave secreta $\mathbf{s}$.

Calcule o seguinte valor: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Se o resultado calculado estiver mais próximo de $0$, a saída é $M=0$; se estiver mais próximo de $\lfloor \frac{q}{2} \rfloor$, a saída é $M=1$.

Vamos expandir matematicamente para ver por que isso permite a descriptografia. Lembre-se de que $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

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

Aqui, $\mathbf{s}^T A^T \mathbf{r}$ foi perfeitamente cancelado e desapareceu da fórmula! O que restou foi $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ é um vetor de ruído cujos componentes são extremamente pequenos, e $\mathbf{r}$ é um vetor binário cujos componentes são 0 ou 1. Portanto, o produto escalar deles, $\mathbf{e}^T \mathbf{r}$, também permanece em um valor relativamente pequeno (se os parâmetros forem escolhidos apropriadamente).

Se $M=0$, o resultado é $\mathbf{e}^T \mathbf{r}$, o que será um valor pequeno próximo de $0$.
Se $M=1$, o resultado é $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, o qual ficará próximo da metade do valor de $q$, $\lfloor \frac{q}{2} \rfloor$.

Se os parâmetros forem desenhados para que o valor absoluto do erro $\mathbf{e}^T \mathbf{r}$ fique abaixo de $\frac{q}{4}$, Bob pode determinar (descriptografar) com precisão a mensagem $M$ apenas olhando se o resultado do cálculo está mais próximo de $0$ ou $\lfloor \frac{q}{2} \rfloor$. Este é o belo mecanismo pelo qual os cifradores baseados em LWE funcionam.

flowchart LR CT["Texto Cifrado (u, v)"] --> Dec SK["Chave Secreta s"] --> Dec subgraph Dec ["Processo de Descriptografia"] direction TB calc["Calcular D = v - s^T * u mod q"] check["Verificar se D está mais próximo de 0 ou q/2"] end calc --> check Dec --> M_out["Mensagem Recuperada M"]

6. Exemplo Prático (Toy Example) de Criptografia LWE com Valores Numéricos Específicos

Pode ser difícil ter uma noção apenas listando equações, então vamos tentar definir parâmetros numéricos muito pequenos e seguir o cálculo desde a criptografia até a descriptografia. (*Em sistemas criptográficos do mundo real, são utilizados valores para $n$ superiores a 500 e $q$ superiores a milhares para garantir a segurança.)

[Configuração de Parâmetros]

Módulo $q = 17$ (Número primo. Assim, os valores variam de $0$ a $16$)
Dimensão $n = 2$
Número de equações $m = 4$
Suponha que vamos criptografar a mensagem $M = 1$.
Quantidade de deslocamento da mensagem: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Fase de Geração de Chaves] Bob seleciona a chave privada $\mathbf{s}$, a matriz $A$ e o vetor de erro $\mathbf{e}$ aleatoriamente.

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

Em seguida, ele calcula a chave pública $\mathbf{b}$.

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

Calculando isto no módulo 17 (por exemplo, $66 = 17 \times 3 + 15$):

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

Adicionando o vetor de erro $\mathbf{e}$:

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

A chave pública será $A$ e $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Fase de Criptografia] Alice criptografa a mensagem $M = 1$. Ela escolhe um vetor aleatório $\mathbf{r}$. Aqui, assumiremos $\mathbf{r} = (1, 0, 1, 0)^T$.

Calculando $\mathbf{u}$:

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

Calculando $v$:

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

Ela adiciona o valor $\lfloor 17/2 \rfloor = 8$ correspondente à mensagem $M=1$.

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

Alice envia o texto cifrado $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ para Bob.

[3. Fase de Descriptografia] Ao receber o texto cifrado, Bob descriptografa usando a chave secreta $\mathbf{s} = (3, 4)^T$. Fórmula do processo de descriptografia: Ele calcula $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

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

Aqui, no mundo de módulo 17, $-8$ é equivalente a $9$ ($-8 + 17 = 9$). Ele verifica se o valor obtido $D = 9$ está mais próximo de $0$ ou $8$ ($\lfloor 17/2 \rfloor$). Uma vez que $9$ é claramente mais próximo de $8$ do que de $0$, Bob conseguiu recuperar corretamente $M = 1$!

Por que se tornou $9$? Lembre-se da prova anterior. A parte do erro é $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Portanto, o resultado do cálculo é $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, confirmando que o valor teórico foi calculado.

7. Evolução para a Prática: Ring-LWE e Module-LWE

O problema LWE Padrão (Standard LWE) explicado até agora possui provas de segurança muito fortes, mas tem uma fraqueza fatal na prática. Esta é o “tamanho da chave torna-se enorme” e “os custos de computação são elevados”.

No Standard LWE, a chave pública contém uma matriz enorme $A \in \mathbb{Z}_q^{m \times n}$. Quando o parâmetro $n$ atinge centenas ou milhares, o tamanho dessa matriz chega a vários megabytes, o que a torna muito pesada para transmissão através de protocolos de comunicação na internet (como TLS) todas as vezes. Além disso, a multiplicação entre matrizes e vetores requer complexidade computacional de $\mathcal{O}(n^2)$.

Para resolver esse problema, “Ring-LWE (RLWE)” e “Module-LWE (MLWE)” foram introduzidos, incorporando a estrutura algébrica dos anéis de polinômios (Polynomial rings) aos reticulados.

7.1 A Intuição do Ring-LWE

No Ring-LWE, vetores e matrizes são substituídos por elementos (polinômios) em um anel de polinômios $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Aqui, $n$ é escolhido como uma potência de 2).

Enquanto a chave pública no LWE Padrão era uma matriz $A$, o Ring-LWE usa um único polinômio $a(x)$. A chave privada $s(x)$ e o erro $e(x)$ também se tornam polinômios. A equação fica assim:

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

Por ser uma multiplicação polinomial, ao usar a “Transformada Numérica de Teoria (Number Theoretic Transform: NTT)”, que é análoga à Transformada Rápida de Fourier (FFT), o custo computacional pode ser drasticamente reduzido para $\mathcal{O}(n \log n)$. Além disso, dado que o tamanho da chave pública é reduzido de uma matriz para um único polinômio, o tamanho dos dados é reduzido para $\mathcal{O}(n)$. Isso traz uma vantagem esmagadora na largura de banda de comunicação.

Matematicamente falando, o Ring-LWE não é sobre reticulados gerais, mas reduz-se a problemas em um reticulado especial simétrico chamado “Reticulado Ideal (Ideal Lattice)”.

7.2 Module-LWE e a Padronização do NIST (Kyber / ML-KEM)

Embora o Ring-LWE seja eficiente, houve alguma preocupação de que a estrutura algébrica especial dos reticulados ideais pudesse se tornar a base para ataques futuros. Portanto, foi criado o “Module-LWE (MLWE)” para obter “o melhor dos dois mundos”, combinando a segurança conservadora do LWE Padrão com a eficiência do Ring-LWE.

No Module-LWE, consideramos pequenos vetores e matrizes cujos elementos são polinômios. Ou seja, lidamos com módulos (modules) sobre um anel. Atualmente, o “CRYSTALS-Kyber” (nome padronizado: ML-KEM), selecionado pelo NIST como o padrão para algoritmos de compartilhamento de chaves (KEM) da PQC, é construído exatamente sobre a dificuldade desse problema Module-LWE.

8. Por que é seguro contra computadores quânticos?

Por fim, tocaremos na questão central: “Por que se acredita que a criptografia baseada em reticulados não pode ser decifrada nem mesmo por computadores quânticos?”.

O algoritmo de Shor, que permite aos computadores quânticos quebrar a criptografia RSA ou a criptografia de curvas elípticas, é essencialmente um algoritmo para resolver o “Problema do Subgrupo Oculto (Hidden Subgroup Problem: HSP)”. As estruturas matemáticas subjacentes à RSA e à ECC (grupos abelianos finitos) possuem periodicidade, e usando a operação específica de algoritmos quânticos chamada Transformada de Fourier Quântica (QFT), esse período (subgrupo oculto) pode ser extraído de uma vez.

Contudo, os problemas de reticulados são fundamentalmente diferentes. Embora os reticulados também tenham periodicidade, o que é requerido em problemas como SVP e CVP são propriedades geométricas não-lineares, como “a distância mais curta” e “a remoção de ruído”. Mesmo que se aplique a “transformada de Fourier quântica sobre grupos abelianos” como no algoritmo de Shor diretamente, informações úteis que poderiam ser a resposta a problemas de reticulados não podem ser extraídas eficientemente. Até o momento, não foram descobertos algoritmos quânticos que resolvam SVP ou LWE em tempo polinomial e acredita-se amplamente que, mesmo com a capacidade de computação paralela dos computadores quânticos, não exista meio eficaz além de uma busca por força bruta (com uma aceleração na raiz quadrada pelo algoritmo de Grover).

9. Conclusão

Neste artigo, explicamos em detalhes a intuição matemática da criptografia baseada em reticulados, começando pela definição geométrica de um reticulado, a formulação do problema LWE e culminando na construção da criptografia de chave pública.

Reticulado (Lattice) é um espaço discreto expresso por uma combinação linear com coeficientes inteiros de vetores de base, e em dimensões altas, torna-se difícil encontrar uma “boa base” quase ortogonal (SVP).
O Problema LWE (Learning With Errors) é o problema de resolver um sistema de equações lineares com ruído, e por estar vinculado à dificuldade do caso mais difícil dos problemas de reticulados, oferece uma poderosa garantia de segurança.
Ao usar o problema LWE, a criptografia e descriptografia (Cifrador Regev) são alcançadas através de um mecanismo inteligente de adição e cancelamento intencional de ruídos.
Em protocolos do mundo real, o Ring-LWE e o Module-LWE usando anéis de polinômios são adotados para aumentar a eficiência de comunicação e velocidade computacional, formando a base do padrão NIST ML-KEM.

À medida que nos aproximamos de uma mudança de paradigma computacional sem precedentes chamada computador quântico, é uma história muito romântica que a “Criptografia baseada em reticulados”, nascida das profundezas da álgebra linear clássica e da teoria dos números, apoiará a fundação da segurança da internet no futuro. A matemática que fundamenta a criptografia de reticulados não é excessivamente complexa, e com conhecimentos básicos de álgebra linear e probabilidade, pode-se entender completamente sua bela estrutura. Esperamos que este artigo ajude na compreensão da criptografia baseada em reticulados, que é o cerne da PQC.

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.

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