RSA on kenji.blog

Apakah Komputer Kuantum Benar-benar Akan Menghancurkan Enkripsi RSA? ~ Algoritma Shor dan Tahap Saat Ini ~

Sat, 05 Sep 2026 22:09:21 +0900

Pengantar: Persimpangan Kriptografi dan Komputer Kuantum

Di masyarakat internet modern, dasar untuk melindungi rahasia komunikasi adalah “Kriptografi Kunci Publik”. Yang paling representatif dari hal ini adalah “Enkripsi RSA” yang dikembangkan pada tahun 1977 oleh Ron Rivest, Adi Shamir, dan Leonard Adleman. Dari pembayaran belanja online, penelusuran situs web (HTTPS), hingga pengiriman dan penerimaan email, enkripsi RSA berfungsi sebagai jantung infrastruktur internet.

Namun, dengan munculnya “komputer kuantum”, ada kemungkinan keamanan ini dihancurkan dari akarnya. Di media berita, kadang-kadang terdapat tajuk utama yang sensasional seperti “Setelah komputer kuantum selesai, semua kata sandi dan enkripsi di dunia akan didekripsi dalam hitungan detik”. Apakah ini benar-benar terjadi?

Artikel ini mendalami mekanisme GNFS (General Number Field Sieve) sebagai metode dekripsi kriptografi klasik, dan algoritma dekripsi definitif menggunakan komputer kuantum, yaitu “Algoritma Shor” (Shor’s Algorithm). Kita akan menjelaskan konsep lanjutan seperti Transformasi Fourier Kuantum dan penemuan periode dengan cara yang mudah dimengerti, serta menyelidiki kondisi perangkat keras kuantum saat ini di era NISQ (Noisy Intermediate-Scale Quantum) dan tantangan nyata untuk menghancurkan RSA-2048.

Inti Enkripsi RSA: Kesulitan Faktorisasi Prima

Keamanan enkripsi RSA bergantung pada asimetri yang sangat sederhana dalam matematika. Fakta bahwa “mudah untuk mengalikan dua bilangan prima raksasa, tetapi sangat sulit untuk menemukan (memfaktorkan) dua bilangan prima asli dari hasil perkalian (bilangan komposit) tersebut”.

Misalnya, mari asumsikan ada dua bilangan prima $ p = 61 $ dan $ q = 53 $. Sangat cepat untuk menghitung perkalian $ N = p \times q = 3233 $. Namun, hanya diberi angka “3233” dan diminta untuk memecahkan “bilangan prima apa dan bilangan prima apa yang dikalikan untuk ini?”, jumlah perhitungan meledak seiring dengan bertambahnya angka.

Dalam RSA-2048 yang saat ini merupakan arus utama, angka komposit besar $ N $ digunakan dengan panjang kunci 2048 bit, atau sekitar 617 digit desimal. Jika $ N $ ini dapat difaktorkan, enkripsinya sama saja dengan sudah terpecahkan.

Tantangan Komputer Klasik: GNFS (General Number Field Sieve)

Untuk memecahkan masalah faktorisasi prima, matematikawan dan ahli kriptografi telah mengembangkan berbagai algoritma selama bertahun-tahun. Di antaranya, yang saat ini dianggap tercepat untuk komputer klasik adalah ** GNFS (General Number Field Sieve) **.

GNFS adalah metode perluasan dan analisis perhitungan dalam cincin bilangan bulat menjadi Number Field aljabar yang lebih abstrak untuk memfaktorkan angka raksasa $ N $. Alurnya secara garis besar sebagai berikut:

** Pemilihan Polinomial **: Temukan polinomial $ f(x) $ dengan derajat dan koefisien yang sesuai yang memiliki $ N $ sebagai akar.
** Pengumpulan Data (Sieving) **: Cari sejumlah besar pasangan angka yang dapat diuraikan menjadi bilangan prima kecil (bilangan halus, Smooth numbers) di atas field rasional dan field aljabar. Proses ini disebut “Sieving” dan merupakan bagian yang paling memakan waktu.
** Pembuatan dan Pengurangan Matriks **: Hasilkan matriks sparse raksasa (sebagian besar elemennya adalah 0) berdasarkan relasi yang dikumpulkan, dan selesaikan dengan menggunakan metode aljabar linier (seperti metode block Lanczos).
** Perhitungan Akar Kuadrat **: Terakhir, hitung akar kuadrat pada field aljabar, dan turunkan faktor (faktor prima) dari $ N $.

Kompleksitas waktu untuk GNFS dievaluasi secara non-asimtotik sebagai $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $. Ini disebut kompleksitas waktu “Sub-eksponensial”. Meskipun lebih cepat dari waktu eksponensial, ini masih jauh lebih lambat dari waktu polinomial.

Faktanya, pada tahun 2020, tim peneliti internasional berhasil memfaktorkan RSA-250 (angka komposit 829 bit, 250 digit) menggunakan GNFS. Perhitungan ini membutuhkan waktu perhitungan yang sangat besar sekitar 2700 core-year CPU, dengan mengumpulkan sumber daya komputasi dari seluruh dunia. Namun, ketika menjadi 2048 bit, jumlah perhitungan yang diperlukan melonjak triliunan kali umur alam semesta, dan tidak peduli berapa banyak superkomputer saat ini yang dijalankan secara paralel, tidak mungkin untuk memecahkannya dalam waktu yang realistis menggunakan metode klasik.

Kartu Truf Komputer Kuantum: Algoritma Shor

Di sinilah “Algoritma Shor”, yang diumumkan oleh Peter Shor pada tahun 1994, muncul. Algoritma ini merupakan terobosan yang dapat memecahkan masalah faktorisasi prima pada komputer kuantum dalam ** waktu polinomial ** ( $ O((\log N)^3) $ ). Perbedaan antara waktu sub-eksponensial dan waktu polinomial sangat menentukan, secara teoritis berarti bahwa jika Anda menggunakan komputer kuantum, enkripsi RSA akan hancur sama sekali.

Alur Keseluruhan Algoritma Shor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[Masukkan angka N yang ingin difaktorkan] --> B[Pilih bilangan bulat acak a]
 B --> C{Faktor persekutuan<br>terbesar a dan N}
 C -->|Lebih dari 1| D[Beruntung menemukan faktor prima!]
 C -->|1 Saling prima| E[Giliran komputer kuantum]
 E --> F[Temukan periode r dari fungsi f_x = a^x mod N<br>dengan Transformasi Fourier Kuantum]
 F --> G{Periode r adalah genap dan<br>a^r/2 ≢ -1 mod N}
 G -->|Ya| H[Hitung faktor persekutuan terbesar gcd_a^r/2 ± 1, N]
 H --> I((Faktorisasi Prima Berhasil!))
 G -->|Tidak| B

Algoritma Shor tidak menyelesaikan masalah faktorisasi prima secara langsung, tetapi mengambil pendekatan menggunakan teorema teori bilangan untuk mengubahnya menjadi masalah lain yang disebut “Period Finding Problem”, dan menyelesaikannya dengan kecepatan tinggi menggunakan karakteristik komputer kuantum.

Langkah 1: Reduksi dari Faktorisasi Prima ke Masalah Penemuan Periode (Pemrosesan Klasik)

Langkah pertama algoritma dilakukan pada komputer klasik. Untuk angka $ N $ yang ingin difaktorkan, pilih bilangan bulat acak $ a $ ( $ 1 < a < N $ ) yang relatif prima terhadap $ N $ (faktor persekutuan terbesar adalah 1). Jika secara kebetulan faktor persekutuan terbesarnya bukan 1, faktor persekutuan yang ditemukan pada saat itu adalah faktor prima dari $ N $, dan dekripsi selesai, tetapi kemungkinannya sangat rendah.

Selanjutnya, pertimbangkan urutan persamaan modulo berikut: $ f(x) = a^x \pmod N $

Saat mengganti $ x = 1, 2, 3, \dots $ ke fungsi $ f(x) $ ini, nilainya tampak acak, tetapi karena dihitung dalam rentang terbatas, nilainya selalu kembali ke aslinya di suatu tempat dan mengulangi urutan bilangan yang sama. Periode pengulangan ini disebut $ r $. Yaitu, $ a^r \equiv 1 \pmod N $ Masalah mencari bilangan bulat positif terkecil $ r $ ini adalah “Period Finding Problem”.

Jika periode $ r $ ini ditemukan dan $ r $ genap, menjadi $ a^r - 1 \equiv 0 \pmod N $, dan dengan menggunakan rumus faktorisasi dapat diubah menjadi $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $. Dari sini, dengan menggunakan algoritma Euclidean untuk menghitung faktor persekutuan terbesar $ N $ dan $ a^{r/2} \pm 1 $, faktor prima $ N $ dapat diperoleh dengan probabilitas yang sangat tinggi.

Untuk menemukan periode $ r $ dengan komputer klasik, bagaimanapun juga langkah eksponensial diperlukan dan tidak dapat dipercepat. Namun, dengan komputer kuantum, periode $ r $ ini dapat ditemukan secara instan (dalam waktu polinomial).

Langkah 2: Persiapan dan Superposisi Keadaan Kuantum

Di sinilah peran komputer kuantum. Komputer kuantum menggunakan “Qubit” yang dapat menahan keadaan “0” dan “1” pada saat yang sama. Dalam algoritma Shor, kami menyiapkan dua register: register pertama untuk menyimpan input, dan register kedua untuk menyimpan hasil perhitungan.

Pertama, operasi gerbang kuantum yang disebut gerbang Hadamard diterapkan ke semua qubit pada register pertama. Akibatnya, register pertama menjadi ** keadaan superposisi merata ** dari semua kemungkinan nilai $ x $ (dari $ 0 $ hingga $ 2^n-1 $. Di mana $ n $ adalah jumlah bit yang cukup besar).

Dengan kata lain, keadaan dibuat di mana nilai input tak terhitung $ x=0, 1, 2, 3, \dots $ ada secara paralel di komputer kuantum.

Langkah 3: Eksponensiasi Modular Kuantum (Quantum Modular Exponentiation)

Selanjutnya, ambil keadaan superposisi register pertama sebagai input, hitung $ f(x) = a^x \pmod N $, dan simpan hasilnya di register kedua. Karena perhitungan ini dijalankan sebagai transformasi kesatuan pada rangkaian kuantum, perhitungan $ f(x) $ untuk semua $ x $ dilakukan “secara paralel secara bersamaan (Paralelisme Kuantum)” sambil mempertahankan superposisi.

Pada titik ini ruang keseluruhan sistem kuantum adalah $ |x, a^x \bmod N\rangle $ yang merupakan superposisi besar keadaan.

Namun, jika kita hanya mengukur (mengamati) register kedua di sini, satu nilai $ a^x \bmod N $ acak dipilih secara probabilistik, dan seiring dengan itu, $ x $ pada register pertama juga akan ditentukan. Ini sama dengan menghitung sekali pada komputer klasik, dan periode $ r $ tidak dapat ditemukan.

Menurut aturan mekanika kuantum, kita tidak bisa mengintip ke dalam keadaan superposisi secara langsung. Lalu, bagaimana kita mengekstrak informasi global tentang “periode” secara keseluruhan?

Langkah 4: Transformasi Fourier Kuantum (QFT: Quantum Fourier Transform)

Inti sebenarnya dari algoritma Shor untuk menembus dinding ini adalah penerapan ** Transformasi Fourier Kuantum (QFT) ** ke register pertama.

Sebelum mengukur, mari kita analisis sifat gelombang dari fungsi $ f(x) $. Misalkan register kedua diamati dan nilai $ y $ tertentu diperoleh. Kemudian keadaan register pertama menyusut ke “superposisi semua $ x $ di mana $ a^x \pmod N = y $”. Nilai $ x $ ini akan diatur secara diskrit dengan interval periode $ r $, seperti $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $ (semacam distribusi probabilitas amplitudo berbentuk sisir).

Terapkan Transformasi Fourier Kuantum (QFT) ke keadaan ini. Sama seperti transformasi Fourier diskrit klasik yang mengubah sinyal dalam domain waktu ke domain frekuensi, QFT menyebabkan interferensi dalam amplitudo probabilitas keadaan kuantum.

Ketika QFT diterapkan, karena efek interferensi kuantum, probabilitas jawaban salah yang tidak beresonansi dengan periode $ r $ (fase tidak cocok) saling meniadakan dan mendekati nol (interferensi destruktif), dan hanya probabilitas jawaban yang benar dengan informasi tentang periode $ r $ yang diperkuat (interferensi konstruktif).

Langkah 5: Pengukuran dan Ekspansi Pecahan Berlanjut (Pemrosesan Klasik Lanjutan)

Ketika register pertama diukur setelah menerapkan QFT, kemungkinan besar akan didapatkan bilangan bulat $ c $ yang mendekati bentuk $ c \approx \frac{j \cdot 2^n}{r} $ ($ j $ adalah bilangan bulat yang tidak diketahui, $ 2^n $ adalah ukuran register).

Kembalikan hasil pengukuran $ c $ ini ke komputer klasik, dan buat pecahan $ \frac{c}{2^n} \approx \frac{j}{r} $. Kemudian, dengan menghitung pendekatan menggunakan metode matematika “Continued fraction expansion”, kita berhasil mengekstraksi penyebut, yang merupakan periode $ r $.

Jika $ r $ diketahui, sisanya adalah menghitung faktor dari $ N $ menggunakan rumus langkah 1, dan enkripsi RSA sepenuhnya hancur.

Kemampuan dan Tantangan Komputer Kuantum Saat Ini (NISQ)

Meskipun secara teoritis algoritma Shor sempurna, jika ditanya, “Apakah enkripsi RSA akan dibobol besok?”, jawabannya jelas “Tidak”. Alasannya terletak pada batasan teknologi perangkat keras komputer kuantum saat ini.

Era NISQ (Noisy Intermediate-Scale Quantum)

Tempat kita berada sekarang adalah era yang disebut “NISQ”. Perangkat NISQ memiliki puluhan hingga ratusan qubit fisik, tetapi sangat rentan terhadap kebisingan.

Qubit rentan terhadap pengaruh lingkungan eksternal seperti panas dan gelombang elektromagnetik, dan sering kali terjadi “Dekoherensi” di mana keadaan kuantum hancur, atau “Kesalahan Gerbang” selama operasi gerbang. Jika seseorang mencoba menjalankan rangkaian kuantum yang sangat dalam (jumlah langkah operasi sangat besar) seperti algoritma Shor, kesalahan akan menumpuk di tengah perhitungan, dan hasil akhirnya hanyalah noise yang sama sekali tidak berarti.

Qubit Fisik dan Qubit Logis

Penting untuk menyelesaikan masalah kesalahan ini dengan “Koreksi Kesalahan Kuantum”. Kode koreksi kesalahan juga digunakan pada komputer klasik, tetapi karena ada “Teorema Larangan Penggandaan Kuantum” yang melarang penyalinan keadaan kuantum, koreksi kesalahan kuantum sangat kompleks.

Dalam koreksi kesalahan kuantum, “Qubit logis” tunggal yang bebas dari kesalahan yang ideal dibuat dengan menggabungkan sejumlah besar “Qubit fisik” yang penuh kebisingan, menggunakan teknologi seperti “Surface Code”.

Dengan asumsi tingkat kesalahan saat ini, diperkirakan dibutuhkan sekitar 1.000 hingga 10.000 qubit fisik untuk membuat satu qubit logis. Ini disebut “Overhead koreksi kesalahan”.

Sumber Daya Apa yang Diperlukan untuk Menghancurkan RSA-2048?

Lalu, berapa banyak sumber daya yang dibutuhkan untuk benar-benar chạy algoritma Shor guna mendekripsi RSA-2048?

Menurut estimasi sumber daya yang memecahkan rekor dalam makalah tahun 2021 oleh Craig Gidney (Google) dan Martin Ekerå, menggunakan algoritma Shor yang dioptimalkan dan melakukan koreksi kesalahan menggunakan Surface Code membutuhkan sumber daya berikut:

** Qubit Logis **: Sekitar 4.096
** Qubit Fisik **: ** Sekitar 20 Juta ** (Berasumsi tingkat kesalahan $10^{-3}$)
** Waktu Perhitungan **: Sekitar 8 jam (membutuhkan jutaan hingga miliaran operasi gerbang fisik)

Sebagai perbandingan, di manakah posisi perangkat keras kuantum saat ini? Prosesor kuantum superkonduktor “Condor” yang diumumkan oleh IBM pada akhir tahun 2023 adalah 1.121 qubit. Penelitian terobosan pada pembangkitan qubit logis (seperti 48 qubit logis menggunakan komputer kuantum atom netral oleh Harvard University dan QuEra) juga telah muncul, tetapi masih belum pada tahap di mana “operasi tanpa noise yang sempurna” dapat dijalankan terus menerus dalam jangka waktu yang lama.

Untuk meningkatkan skala dari beberapa ribu qubit fisik ke ** 20 juta ** qubit fisik praktis (sistem yang saling terhubung, stabil pada suhu kriogenik, dan memproses sinyal kontrol super cepat), ada kendala rekayasa besar (masalah pemasangan kabel, batasan kapasitas pendinginan, peningkatan elektronik kontrol). Banyak ahli memperkirakan akan memakan waktu setidaknya 10 hingga 30 tahun, atau lebih lama, untuk merealisasikan “Komputer Kuantum Toleransi Kesalahan” (FTQC) yang mampu memecahkan RSA-2048.

Ancaman yang Mengintai “Store Now, Decrypt Later” dan Fajar PQC

Adalah terlalu dini untuk berpikir bahwa “Aman karena masih butuh lebih dari 10 tahun”. Saat ini, terdapat data rahasia negara, data medis, dan desain infrastruktur jangka panjang yang rahasianya harus dijamin untuk beberapa dekade mendatang.

Yang menjadi perhatian di sini adalah metode serangan ** “Store Now, Decrypt Later” (Simpan Sekarang, Dekripsi Nanti) **. Negara atau organisasi yang berniat jahat dapat mencegat semua data komunikasi yang saat ini dienkripsi dengan RSA atau ECC, dan menyimpannya. Kemudian, dalam 10 atau 20 tahun, segera setelah komputer kuantum yang kuat selesai dibangun, mereka akan menggunakan algoritma Shor untuk memecahkan semua data yang lalu dan mengungkap rahasianya.

Untuk mengatasi ancaman kelambatan waktu ini, proses standardisasi ** “Kriptografi Pasca-Kuantum” (PQC: Post-Quantum Cryptography) ** telah berjalan dengan kecepatan penuh, berpusat di NIST (National Institute of Standards and Technology AS).

PQC adalah algoritma enkripsi baru berdasarkan masalah matematika yang sulit dipecahkan bahkan dengan komputer kuantum (dengan kata lain, algoritma Shor tidak dapat diterapkan). Pendekatan utamanya adalah:

** Kriptografi berbasis Kisi (Lattice-based cryptography) **: Berdasarkan masalah seperti LWE (Learning with Errors). Ini arus utama dalam standardisasi NIST (Kyber, Dilithium, dll.).
** Kriptografi berbasis Kode (Code-based cryptography) **: Mengandalkan sulitnya masalah decoding dari kode koreksi kesalahan.
** Kriptografi Multivariat (Multivariate cryptography) **: Mengandalkan sulitnya memecahkan sistem persamaan polinomial kuadratik multivariat.
** Tanda Tangan berbasis Hash (Hash-based signatures) **: Tanda tangan digital yang hanya mengandalkan keamanan fungsi hash.

Platform perangkat lunak utama seperti Google Chrome dan Apple iMessage sudah mulai menguji implementasi PQC atau integrasi hybrid.

Kesimpulan

Komputer kuantum sedang bergeser dari impian fiksi ilmiah menjadi tantangan teknik dunia nyata. Algoritma Shor adalah pencapaian intelektual umat manusia yang hebat yang menggabungkan matematika dan mekanika kuantum, tetapi pada saat yang sama memegang “kekuatan destruktif” untuk mengguncang fondasi masyarakat digital kita.

Enkripsi RSA tidak akan berhenti menjadi tidak berguna besok. Namun, mengingat evolusi teknologi kuantum dan risiko “Store Now, Decrypt Later”, migrasi skala besar dalam sejarah kriptografi ke PQC sudah dimulai. Kita sekarang menyaksikan garis depan pergeseran paradigma dalam keamanan informasi.

[Bedah Lengkap] Memahami Algoritma Kriptanalisis Terkuat "GNFS" dengan Mengimplementasikannya di C++

Sat, 05 Sep 2026 13:04:59 +0900

[Bedah Lengkap] Memahami Algoritma Kriptanalisis Terkuat “GNFS” dengan Mengimplementasikannya di C++

“Kriptografi RSA” mendukung dasar dari internet modern. Kekuatannya bergantung pada keyakinan matematis bahwa “memfaktorkan bilangan komposit yang sangat besar menjadi faktor prima secara praktis tidak mungkin dilakukan oleh komputer saat ini”.

Namun, umat manusia tidak pernah menyerah. Saat ini, terdapat ** algoritma terkuat dan paling canggih buatan manusia ** untuk faktorisasi prima besar pada komputer klasik (komputer biasa, bukan komputer kuantum). Ini disebut ** “General Number Field Sieve (GNFS)” **.

Dalam artikel ini, kami akan merilis secara lengkap kode implementasi C++ (menggunakan integer presisi ganda boost::multiprecision dari pustaka Boost) yang memodelkan secara ketat logika komputasi canggih dari GNFS ini. Kami juga akan menjelaskan secara mendalam tentang “teori bilangan aljabar” di baliknya.

Silakan nikmati misteri matematika dan kekuatan ilmu komputer yang menaklukkannya bersama dengan kode sumbernya.

1. Kerangka Logika Canggih GNFS (Kode Sumber Lengkap)

Pertama, mari kita lihat gambaran keseluruhan implementasi GNFS C++ yang akan kita bahas kali ini. Sistem Number Field Sieve yang sebenarnya (seperti CADO-NFS) adalah sistem terdistribusi raksasa dengan ratusan ribu baris kode. Namun, kode ini dirancang dengan mengekstrak ** “5 alur (fase) esensial” ** yang membentuk GNFS menjadi kelas-kelas, memodelkannya dalam konfigurasi minimal tanpa kehilangan makna matematisnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Menggunakan integer presisi ganda Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve Kerangka Logika Tercanggih
//
// Kode ini secara ketat memodelkan 5 alur dari GNFS canggih
// yang digunakan dalam CADO-NFS dll., sebagai desain kelas C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Fase 1: Pemilihan Polinomial (Algoritma KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinomial sisi aljabar f(x)
 std::vector<cpp_int> g; // Polinomial sisi rasional g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Pembuatan polinomial awal berdasarkan ekspansi basis-m (pada kenyataannya menggunakan reduksi basis kisi LLL yang lebih canggih)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Pemilihan Polinomial (Derajat " << degree << ") dimulai..." << std::endl;
 // Ekspansi basis-m sederhana (derajat d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Perkiraan m yang sederhana (perkiraan tanpa menggunakan fungsi Boost)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Fase 1] Selesai." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Penyaringan Kisi)
// ============================================================================
// GNFS modern tidak menggunakan Line Sieve (Penyaringan Garis), tetapi
// menggunakan Special-q Lattice Sieving oleh Franke-Kleinjung sebagai standar de facto.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Fase 2] Membuat Basis Faktor (Batas Rasional: " << rational_bound << ", Batas Aljabar: " << algebraic_bound << ")" << std::endl;
 // (Dihilangkan) Pada kenyataannya, pembuatan bilangan prima dan pemfilteran dengan simbol Legendre dilakukan
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving aktif..." << std::endl;
 std::vector<Relation> relations;
 // Implementasi tiruan: Saringan kisi sebenarnya memindai ruang memori ratusan GB dalam blok
 // (a, b) pasangan dipetakan ke kisi (a = i*q + j*...) untuk setiap prima khusus q,
 // dan saringan yang memaksimalkan efisiensi cache dijalankan.

 // Menambahkan satu relasi tiruan untuk demo
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Fase 2] Ditemukan " << relations.size() << " relasi." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Pembersihan Singleton dan Penggabungan Clique)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Menyaring Relasi..." << std::endl;
 // 1. Penghapusan singleton (menghapus relasi dengan prima yang muncul hanya sekali)
 // 2. Penggabungan clique (menggabungkan relasi untuk mengubah matriks jarang menjadi padat)
 // Pada kenyataannya, algoritma seperti Union-Find digunakan untuk mengompres matriks ratusan juta baris menjadi beberapa juta baris.
 std::cout << "[Fase 3] Ukuran matriks dikurangi secara optimal." << std::endl;
 }
};

// ============================================================================
// Fase 4: Aljabar Linier di atas GF(2) (Metode Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // Dalam lingkungan superkomputer modern, daripada metode Block Lanczos,
 // metode Block Wiedemann (Implementasi Coppersmith) yang cocok untuk komputasi terdistribusi digunakan sebagai teknologi mutakhir.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritma Block Wiedemann di atas GF(2) dimulai..." << std::endl;
 // Mengulangi operasi produk antara matriks jarang (sparse) dan vektor,
 // menemukan beberapa vektor solusi (kernel) yang memenuhi M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Daftar dependensi
 // Data tiruan
 dependencies.push_back({0});

 std::cout << "[Fase 4] Ditemukan " << dependencies.size() << " dependensi linier (kuadrat sempurna)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Akar Kuadrat Aljabar (Algebraic Square Root)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Fase 5] Komputasi Akar Kuadrat Aljabar..." << std::endl;

 // 1. Komputasi akar kuadrat V dari sisi rasional (operasi bilangan bulat sederhana)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Komputasi akar kuadrat gamma dari sisi aljabar (Metode Montgomery, dll.)
 // Menemukan elemen gamma dari field aljabar besar O_K dan memetakannya ke dunia nyata dengan homomorfisme phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Diasumsikan bahwa barisan Karakter Kuadrat (Quadratic Characters) telah ditambahkan di Fase 2 dan 4
 // untuk menghindari hambatan (Obstruction) dari grup kelas ideal dan grup unit.

 std::cout << " -> Peta homomorfisme phi diterapkan." << std::endl;
 std::cout << "[Fase 5] Menghitung FPB(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // FPB(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUKSES] Faktor non-trivial ditemukan: " << factor << std::endl;
 std::cout << " Faktor lain: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[GAGAL] Solusi trivial. Mencoba dependensi berikutnya..." << std::endl;
 }
 }
};

// ============================================================================
// Alur Eksekusi Utama
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Mesin General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Bilangan komposit raksasa N yang ingin difaktorkan, seperti RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Derajat polinomial (untuk lebih dari 130 digit, biasanya dipilih derajat 5 hingga 6)
 int degree = 6;

 // Inisialisasi alur
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Batas sebenarnya adalah puluhan hingga ratusan juta
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Pemilihan polinomial
 poly_select.select(N);

 // 2. Proses penyaringan (sieve)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Penyaringan (kompresi matriks)
 filter.reduce_matrix(relations);

 // 4. Aljabar linier (Pencarian ruang nol di atas GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Perhitungan akar kuadrat aljabar dan FPB
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[Sistem] Alur SOTA GNFS selesai dalam " << elapsed.count() << " detik." << std::endl;

 return 0;
}

Lalu, bagaimana kode ini bekerja menghancurkan dinding kriptografi? Kita akan memecah dan menjelaskan algoritma yang cermat dan matematika lanjutan untuk setiap 5 fase.

2. Tujuan Akhir GNFS: $X^2 \equiv Y^2 \pmod N$

Tidak hanya GNFS, tujuan dari sebagian besar algoritma faktorisasi prima raksasa modern adalah menemukan pasangan non-trivial $(X, Y)$ yang memenuhi persamaan kongruensi berikut:

$$X^2 \equiv Y^2 \pmod N$$

Persamaan ini berarti “sisa pembagian $X^2$ dan $Y^2$ oleh $N$ adalah sama”. Jika kita mengubah ini, $X^2 - Y^2 \equiv 0 \pmod N$ Dengan kata lain, $(X-Y)(X+Y)$ adalah kelipatan $N$.

Jika $X \not\equiv \pm Y \pmod N$ (solusi non-trivial), maka akan ada “pembagi persekutuan yang lebih besar dari 1 dan lebih kecil dari $N$” antara $(X-Y)$ dan $N$. Di sini, jika kita menggunakan Algoritma Euclidean untuk menghitung ** $\gcd(X-Y, N)$ **, kita dapat dengan mudah menemukan faktor prima dari $N$.

Namun, menemukan $X$ dan $Y$ ini seperti mencari jarum di padang pasir. Oleh karena itu, GNFS mengambil pendekatan jenius dengan mendistribusikan komputasi dengan menciptakan ** dua dunia **: “dunia bilangan bulat nyata” dan “dunia field aljabar polinomial”.

3. Fase 1: Pemilihan Polinomial (Polynomial Selection)

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // perhitungan m = N^(1/d) dan ekspansi basis-m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

Langkah pertama GNFS adalah membuat “polinomial ajaib” untuk menjembatani dua dunia tersebut. Untuk bilangan $N$ yang sangat besar, kita memilih bilangan bulat $m$. Biasanya kita memilih agar $m \approx N^{1/d}$ (dalam kode, kita mengasumsikan polinomial derajat $d=6$).

Kemudian, $N$ diekspansi ke basis $m$, dan polinomial $f(x)$ dibangun menggunakan koefisien tersebut:

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Polinomial $f(x)$ ini memiliki sifat yang sangat penting yaitu ** “jika kita menyubstitusikan $m$ ke variabel $x$, nilainya tepat $N$ ($f(m) = N$)” **. Dengan kata lain, $f(m) \equiv 0 \pmod N$. Polinomial sisi rasional didefinisikan sebagai $g(x) = x - m$.

Sebagai hasilnya, ** “dunia field aljabar $\mathbb{Z}[\alpha]$” ** yang diatur oleh akar $\alpha$ dari $f(x)=0$ dan ** “dunia rasional (bilangan bulat) $\mathbb{Z}$” ** biasa akan terikat kuat oleh “Homomorfisme Ring” $x \to m$.

Dalam CADO-NFS termutakhir dan lainnya, algoritma KleinJung dan algoritma reduksi basis kisi LLL digunakan untuk mencari “polinomial terbaik $f(x)$” di mana koefisien polinomial tidak menjadi terlalu besar, dan bilangan prima cenderung muncul (mudah menjadi mulus) pada langkah selanjutnya, yang memakan waktu pencarian berbulan-bulan.

4. Fase 2: Special-q Lattice Sieving (Penyaringan Kisi q-Khusus)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Pasangan (a, b) dipetakan ke kisi untuk setiap bilangan prima khusus q,
 // dan saringan (sieve) yang memaksimalkan efisiensi cache dijalankan.
 // ...
 }
};

Setelah kedua dunia disiapkan, langkah selanjutnya adalah mencari “bilangan mulus (smooth number - bilangan yang hanya terdiri dari faktor prima kecil)” di kedua dunia tersebut. Jumlah pasangan integer $(a, b)$ yang tak terhingga dihasilkan, dan dua nilai berikut dihitung:

Nilai sisi rasional : $a - bm$
Norma sisi aljabar : $b^d f(a/b)$

Tujuan GNFS adalah mengumpulkan puluhan hingga ratusan juta dari ** “pasangan di mana baik nilai sisi rasional maupun aljabar dapat diuraikan sepenuhnya hanya menggunakan faktor prima kecil (Relasi)” **.

Pada GNFS awal, digunakan “Line Sieve”, di mana pasangan $(a, b)$ disusun pada bidang $xy$ dan dibagi dengan bilangan prima secara berurutan. Namun, metode ini sangat lambat karena menyebabkan banyak cache miss saat mengakses memori.

Oleh karena itu, kode modern tercanggih menggunakan metode yang disebut ** “Special-q Lattice Sieve” **. Sebuah bilangan prima sedang yang cukup besar $q$ ditetapkan, dan hanya pasangan $(a, b)$ di mana “nilai sisi aljabar pasti habis dibagi $q$” yang dihitung. Pasangan $(a, b)$ yang memenuhi kondisi ini membentuk “Lattice (Kisi)” di bidang, membuat lompatan alamat yang dihitung konstan, dan sangat pas di cache L1/L2 CPU. Pengenalan penyaringan kisi ini sangat meningkatkan kecepatan perhitungan GNFS.

5. Fase 3: Filtering (Penyaringan)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Penghapusan Singleton (menghapus relasi dengan prima yang muncul hanya 1 kali)
 // 2. Penggabungan Clique (menggabungkan relasi untuk memadatkan matriks yang jarang)
 }
};

Ratusan juta relasi yang dikumpulkan oleh komputer di seluruh dunia selama beberapa bulan pada Fase 2. Namun, jika kita memasukkannya langsung ke “langkah memecahkan sistem persamaan (perhitungan matriks)” berikutnya, memori superkomputer akan penuh sesak.

Oleh karena itu, proses kompresi ekstrem dari matriks yang disebut ** Filtering ** dilakukan.

Penghapusan Singleton (Pembersihan Singularitas) Misalkan sebuah bilangan prima besar $p$ muncul “hanya 1 kali” dari ratusan juta relasi. Tujuan kita adalah “membuat pangkat semua bilangan prima genap (kelipatan 2)”, jadi bilangan prima yang hanya muncul 1 kali tidak akan pernah genap. Oleh karena itu, relasi yang mengandung prima tersebut langsung dihapus (dibersihkan) sebagai “sampah yang tidak berguna”. Karena hal ini terjadi berantai, ratusan juta baris data akan dipangkas.
Penggabungan Clique (Clique Merging) Selanjutnya, dengan mengalikan (menambahkan) relasi yang berbagi bilangan prima tertentu, matriks yang jarang (sparse) dipadatkan (dikompres) sementara jumlah baris dikurangi (mirip dengan pencarian clique di teori graf).

Melalui pengoptimalan ini, matriks sparse raksasa dikompresi secara dramatis menjadi ukuran yang dapat dihitung.

6. Fase 4: Aljabar Linier atas GF(2) (Metode Block Wiedemann)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Mengulangi perhitungan produk matriks jarang dan vektor,
 // dan menemukan beberapa vektor solusi (kernel) untuk M * x = 0 mod 2.
 }
};

Kini kita tiba di inti teka-teki. Kita mengalikan relasi yang terkumpul untuk mencari ** “kombinasi di mana pangkat semua faktor prima menjadi genap” **.

Secara matematis, menggunakan matriks raksasa $M$ yang elemen-elemennya mewakili “genap atau ganjil (yaitu 0 atau 1)” dari pangkat setiap prima, dan vektor $x$ yang merepresentasikan relasi mana yang digunakan, kita perlu menyelesaikan vektor $x$ (Null space / Kernel) sehingga: $M \cdot x \equiv 0 \pmod 2$

Kita harus memecahkan sistem persamaan sebuah matriks sebesar jutaan baris × jutaan kolom. Eliminasi Gauss konvensional membutuhkan kompleksitas $O(N^3)$, yang berarti perhitungannya takkan selesai hingga alam semesta berakhir.

Oleh karena itu, implementasi termutakhir menggunakan ** “Metode Block Wiedemann” **. Ini adalah jenis metode subruang Krylov yang menemukan solusi melalui iterasi perkalian matriks-vektor, memanfaatkan fakta bahwa matriks $M$ sangat “sparse (sebagian besar 0)”. Tidak seperti metode Block Lanczos yang lama, Block Wiedemann secara penuh membagi proses komputasi ke dalam berbagai cluster, menunjukkan kekuatan besar dalam komputasi awan terdistribusi modern maupun superkomputer.

7. Fase 5: Algebraic Square Root (Akar Kuadrat Aljabar) dan Kehancuran Kriptografi

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Perhitungan akar kuadrat V dari sisi rasional
 cpp_int V = 1;

 // 2. Perhitungan akar kuadrat gamma dari sisi aljabar
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Melalui perhitungan matriks di Fase 4, kita mendapatkan himpunan relasi $S$ yang “jika dikalikan, semua faktor primanya akan berpangkat genap”. Dengan ini, kita dapat menyusun “kuadrat” pada masing-masing dunia rasional dan aljabar.

Karena sisi rasional hanyalah perkalian bilangan bulat, akar kuadrat $V$ mudah dihitung.

$$V^2 = \prod_{S} (a - bm)$$

Namun, neraka sesungguhnya terletak di “sisi aljabar”. Di dunia field aljabar $\mathbb{Z}[\alpha]$, keunikan faktorisasi prima tidak berlaku, maka komputasi dilakukan menggunakan ideal. Perhitungan matriks hanya memastikan itu ** “menjadi kuadrat sebuah ideal”, tetapi tidak “menjamin bahwa ia merupakan kuadrat dari sebuah elemen ($\gamma^2$)” **.

Di sinilah hambatan (Obstruction) kuat teori bilangan aljabar menghalangi, yang disebut “Hambatan Grup Kelas Ideal” dan “Hambatan Grup Unit”. GNFS menembus dinding ini dengan menggunakan keajaiban yang disebut ** “Karakter Kuadrat (Quadratic Characters)” **. Ke dalam matriks Fase 4, kita diam-diam menambahkan beberapa kolom residu kuadrat (Simbol Legendre) untuk beberapa puluh ideal prima khusus sebelumnya. Berkat hal ini, himpunan $S$ yang ditemukan akan lolos dari hambatan dengan probabilitas sangat tinggi, dan berhasil membentuk “kuadrat elemen sejati $\gamma^2$”.

Tugas menemukan $\gamma$ (Akar Kuadrat Aljabar) dihitung dengan menggunakan algoritma yang sangat kompleks seperti Metode Montgomery.

Dan pada akhirnya, akar kuadrat aljabar $\gamma$ di-warp ke dunia nyata oleh homomorfisme ring $\phi$ (mensubstitusikan $m$ ke $x$), untuk memperoleh $Y$. Dengan menetapkan $V$ di sisi rasional sebagai $X$, maka persamaan mutlak yang kita cari pun sempurna terbentuk.

$$X^2 \equiv Y^2 \pmod N$$

Yang tersisa hanyalah menghitung $\gcd(X-Y, N)$. Hanya dalam 0,001 detik, ketika faktor non-trivial tercetak di layar, Kriptografi RSA yang dianggap tak tergoyahkan hancur sepenuhnya.

Kesimpulan

GNFS bukan sekadar teknik pemrograman. Ini adalah mahakarya intelijen umat manusia yang menaklukkan “kedalaman matematika murni” seperti aljabar abstrak, teori ring, dan grup kelas ideal menggunakan “teknik tingkat tinggi” seperti arsitektur terdistribusi superkomputer dan optimasi cache.

Informasi chat atau kartu kredit kita yang biasa kita kirim setiap hari, ternyata dilindungi oleh pertempuran matematis yang sangat besar seperti ini.

Kami berharap melalui kerangka C++ ini, Anda bisa merasakan “romantisme matematika dan komputer” di balik algoritma pemecahan kode yang mutakhir.

Struktur Matematis Sejati dari General Number Field Sieve (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

Struktur Matematis Sejati dari General Number Field Sieve (GNFS)

Tujuan akhir dari GNFS adalah menemukan $X, Y$ sedemikian rupa sehingga $X^2 \equiv Y^2 \pmod N$. Untuk mencapai ini, para matematikawan membangun sebuah jembatan antara “dunia bilangan bulat nyata” dan “dunia medan aljabar”. Jembatan tersebut adalah “homomorfisme”.

Tahap 1: “Homomorfisme” (Homomorphism) yang Menghubungkan Dunia

1. Pemilihan Polinomial dan Definisi Akar

Untuk sebuah bilangan komposit raksasa $N$, kita memilih sebuah bilangan bulat $m$ dan polinomial $f(x)$ sedemikian rupa sehingga $f(m) \equiv 0 \pmod N$. (Contoh: Ekspansi $N$ dalam basis $m$, dan buat $f(x)$ dari koefisien-koefisiennya. Dalam hal ini, $f(x)$ diasumsikan tak tereduksi di atas medan bilangan rasional $\mathbb{Q}$).

Selanjutnya, misalkan $\alpha$ adalah salah satu “akar bilangan kompleks” dari persamaan $f(x) = 0$. Tentu saja, $f(\alpha) = 0$. $\alpha$ bukanlah bilangan bulat, melainkan bilangan kompleks (bilangan aljabar) yang dapat memuat akar atau bilangan imajiner.

2. Konstruksi Cincin (Ring) dan Homomorfisme

Di sini, kita menyiapkan dua “cincin” matematis (dunia di mana penjumlahan dan perkalian didefinisikan):

Dunia A: $\mathbb{Z}[\alpha]$ (Cincin bilangan bulat aljabar yang mengandung $\alpha$) Ini adalah dunia bilangan yang diekspresikan dalam bentuk $a + b\alpha + c\alpha^2 + \dots$.
Dunia B: $\mathbb{Z}/N\mathbb{Z}$ (Cincin sisa pembagian dengan $N$) Dunia kongruensi (modulo) yang hanya terdiri dari bilangan bulat dari $0$ hingga $N-1$.

Di sini, kita mendefinisikan sebuah pemetaan (mapping) $\phi$ dari Dunia A ke Dunia B sebagai berikut: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Pemetaan $\phi$ ini adalah operasi magis yang sepenuhnya menukar variabel $\alpha$ di Dunia A dengan bilangan bulat $m$ di Dunia B. $\phi$ ini memiliki sifat yang sangat kuat yang disebut “Homomorfisme Cincin” (Ring Homomorphism). Homomorfisme adalah sifat “berpindah ke dunia lain tanpa merusak struktur penjumlahan dan perkalian”. Artinya, persamaan berikut berlaku:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

Apa arti semua ini? Jika kita dapat membuat “bentuk kuadrat” ($\gamma^2$) dari elemen kompleks $\gamma$ di “Dunia A” (dunia $\alpha$), kita dapat melompat ke “Dunia B” (dunia sisa) dengan $\phi$, dan bentuk kuadrat $\phi(\gamma)^2$ akan dipertahankan dengan sempurna.

Tahap 2: Runtuhnya Faktorisasi Prima dan Lahirnya “Ideal”

Kita ingin mengumpulkan banyak elemen $(a - b\alpha)$ yang sesuai dalam Dunia A ($\mathbb{Z}[\alpha]$) dan mengalikannya bersama untuk membuat “kuadrat sempurna” (elemen kuadrat). Biasanya, kita dapat melakukan “faktorisasi prima” pada $(a - b\alpha)$ yang dikumpulkan, dan menggabungkannya sehingga semua pangkat bilangan prima menjadi genap (dipecahkan menggunakan matriks) untuk menghasilkan bentuk kuadrat.

Namun, di sinilah tembok keputusasaan aljabar menghalangi jalan. Di dunia medan aljabar seperti $\mathbb{Z}[\alpha]$, “keunikan faktorisasi prima (setiap bilangan dapat dinyatakan hanya dengan satu cara sebagai perkalian bilangan prima)” yang kita pelajari di sekolah menengah runtuh sama sekali.

(Contoh: Di beberapa dunia medan aljabar, $6 = 2 \times 3$, dan pada saat yang sama $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, sehingga mustahil untuk mengetahui mana yang merupakan bilangan prima sejati).

Jika faktorisasi prima tidak unik, teka-teki “menghitung bilangan prima hingga jumlahnya genap” (metode saringan) pada prinsipnya tidak dapat dijalankan.

Keselamatan dari Kummer dan Dedekind: “Ideal”

Keruntuhan ini diselamatkan oleh konsep “Ideal” (Bilangan Ideal) yang diciptakan oleh matematikawan abad ke-19. Alih-alih melihat elemen itu sendiri, dengan mempertimbangkan “himpunan kelipatan (ideal)” yang dihasilkan oleh elemen tersebut, faktorisasi prima menjadi mungkin kembali.

Dalam cincin bilangan bulat dari medan aljabar $\mathcal{O}_K$ (cincin yang lebih sempurna yang mengandung $\mathbb{Z}[\alpha]$), bahkan jika elemen tidak dapat difaktorkan secara unik, terbukti bahwa “Ideal selalu dapat difaktorkan secara unik sebagai hasil kali ‘Ideal Prima’ ($\mathfrak{p}$)”.

Oleh karena itu, di GNFS, alih-alih memfaktorkan elemen $(a - b\alpha)$ itu sendiri, kita melakukan faktorisasi ideal prima pada ideal utama $\langle a - b\alpha \rangle$ yang dihasilkannya.

Tahap 3: Norma (Norm) dan Dua Saringan (Sieve)

Lalu, bagaimana kita tahu ke ideal prima mana ideal $\langle a - b\alpha \rangle$ terurai? Di sini kita menggunakan sebuah fungsi yang disebut “Norma” (Norm). Norma adalah fungsi yang mengubah elemen kompleks dari medan aljabar menjadi “bilangan bulat biasa $\mathbb{Z}$” di dunia nyata.

Norma dari elemen $(a - b\alpha)$ dihitung dengan polinomial sederhana $b^d f(a/b)$ (di mana $d$ adalah derajat $f(x)$).

Berdasarkan teorema aljabar, diketahui bahwa “jika norma suatu ideal dapat difaktorkan sepenuhnya oleh bilangan prima kecil (halus), maka ideal aslinya juga dapat difaktorkan sepenuhnya oleh ideal prima kecil”.

Oleh karena itu, GNFS secara bersamaan menghitung dua hal berikut untuk sejumlah besar pasangan bilangan bulat $(a, b)$, dan hanya mengumpulkan pasangan di mana keduanya adalah “bilangan halus”:

Saringan Rasional (Rational Sieve): $a - bm$ (nilai di dunia nyata)
Saringan Aljabar (Algebraic Sieve): $b^d f(a/b)$ (norma di dunia medan aljabar)

Kita mengumpulkan puluhan juta pasangan $(a, b)$ yang keduanya halus, memecahkan data faktorisasi prima ideal (berapa banyak ideal prima yang ada) sebagai matriks raksasa (aljabar linear atas GF(2)), dan menemukan himpunan $S$ dari pasangan sedemikian rupa sehingga “ketika dikalikan, pangkat semua ideal prima menjadi genap”.

Tahap 4: Dua “Rintangan” dan Grup Kelas Ideal

Melalui perhitungan matriks, kita menemukan bahwa mengalikan semua ideal $(a - b\alpha)$ dalam himpunan $S$ menghasilkan kuadrat dari suatu ideal $I$.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

Namun, ini belum berakhir. Tembok matematika terdalam dan tersulit di GNFS ada di sini.

Apa yang pada akhirnya kita inginkan bukanlah “kuadrat dari ideal”, melainkan “kuadrat dari elemen” ($\gamma^2$) untuk disubstitusikan ke dalam pemetaan $\phi$. Hanya karena ideal dikuadratkan, tidak berarti elemen itu sendiri dikuadratkan. Ada dua rintangan matematika yang sangat kuat (Obstructions) di sini.

Rintangan 1: Tembok Grup Kelas Ideal (Ideal Class Group)

Ideal $I$ tidak selalu “ideal yang dihasilkan oleh satu elemen (ideal utama)”. Mustahil untuk mengekstrak elemen spesifik $\gamma$ dari ideal yang bukan merupakan ideal utama.

Di sinilah konsep “Grup Kelas Ideal (Class Group, $Cl_K$)” muncul. Grup Kelas Ideal adalah sebuah grup yang mengukur “berapa banyak ideal non-utama yang ada di dunia medan aljabar (seberapa banyak keunikan faktorisasi prima telah rusak)”. Bahkan jika $\prod \langle a - b\alpha \rangle$ menjadi $I^2$, jika $I$ bukan elemen identitas (ideal utama) dalam grup kelas ideal, kita tidak dapat menariknya kembali menjadi kuadrat elemen.

Rintangan 2: Tembok Grup Unit (Unit Group)

Misalkan kita beruntung dan $I$ adalah ideal utama $\langle \gamma \rangle$. Maka, $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Anda mungkin berpikir, “Bagus, elemennya juga kuadrat!”, tetapi Anda salah besar.

Fakta bahwa ideal (himpunan kelipatan) sama tidak berarti bahwa elemen-elemennya sepenuhnya sama. Akan selalu ada pergeseran berupa “Unit” (bilangan yang kebalikannya juga berupa bilangan bulat, seperti 1 atau -1). Dengan kata lain, persamaan elemen yang sebenarnya adalah sebagai berikut:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

(di mana $u$ adalah elemen dari grup unit $U_K$)

Kecuali unit $u$ ini sendiri adalah kuadrat dari sesuatu (elemen kuadrat), sisi kiri tidak akan pernah bisa menjadi “kuadrat elemen yang sempurna”.

Tahap 5: Sihir Adleman “Karakter Kuadratik” (Quadratic Characters)

Rintangan grup kelas ideal dan rintangan grup unit. Bagaimana kita mengatasi keduanya? Di sinilah muncul metode jenius yang disebut “Karakter Kuadratik” (Quadratic Characters), yang diperkenalkan oleh kriptografer Leonard Adleman (huruf “A” di RSA) dan rekan-rekannya.

Untuk menentukan apakah “suatu elemen benar-benar kuadrat sempurna di medan aljabar”, kita menggunakan versi medan aljabar dari simbol Legendre (residu kuadrat). Pada matriks raksasa tadi (teka-teki untuk membuat jumlah ideal prima genap), kita secara diam-diam menambahkan beberapa lusin kondisi tambahan (kolom) yang menyatakan bahwa “karakter kuadratik untuk beberapa ideal prima khusus $\mathfrak{q}$ juga semuanya menjadi $1$ (genap)”.

Ketika kita menemukan himpunan $S$ yang memenuhi kondisi tambahan ini melalui perhitungan matriks, sebuah teorema mendalam dari teori bilangan aljabar menjamin bahwa “baik rintangan grup kelas ideal maupun rintangan grup unit secara alami akan hilang dengan probabilitas yang sangat tinggi”.

Dengan ini, kita akhirnya mendapatkan persamaan yang sebenarnya:

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Tahap Akhir: Penyatuan Dunia dan Keruntuhan Kriptografi

Akhirnya, semua potongan teka-teki sudah lengkap.

[Elemen di Dunia Medan Aljabar (Dunia A)] $\gamma^2 = \prod (a - b\alpha)$ (Gunakan algoritma akar kuadrat untuk menemukan $\gamma$)

[Elemen di Dunia Nyata (Dunia Rasional)] $V^2 = \prod (a - bm)$ (Ini hanyalah perkalian bilangan bulat biasa, jadi akar kuadrat $V$ dapat ditemukan dengan mudah)

Sekarang, saatnya jembatan ajaib pertama yang kita buat, homomorfisme $\phi$, beraksi. Kita melompati elemen $\gamma$ dari Dunia A ke Dunia B (dunia sisa $N$) menggunakan $\phi$ (pemetaan yang menyubstitusikan $m$ ke dalam $\alpha$).

$$Y = \phi(\gamma) \pmod N$$

Di sisi lain, kita membawa $V$ yang dibuat di dunia nyata langsung ke dunia sisa dan menyebutnya $X$.

$$X = V \pmod N$$

Berkat sifat “mempertahankan struktur” dari homomorfisme, hubungan kuadrat yang berlaku di Dunia A dipertahankan dengan sempurna di Dunia B (dunia modulo $N$). Lebih jauh lagi, karena pasangan asli $(a, b)$ dibentuk dengan cara yang berkorespondensi sebagai $a - b\alpha$ dan $a - bm$, $X$ dan $Y$ ini saling bertabrakan di dunia modulo $N$ dan menghasilkan persamaan absolut berikut:

$$X^2 \equiv Y^2 \pmod N$$

Sekarang, tinggal berdoa agar $X$ dan $Y$ bukan merupakan solusi trivial ($X \equiv \pm Y$), lalu kita hitung: $\gcd(X - Y, N)$

Jika itu adalah solusi non-trivial, algoritma Euclidean akan melesat dalam 0,001 detik, dan bilangan prima rahasia $p$ dan $q$, yang merupakan jantung kriptografi RSA, akan dicetak di layar keluaran.

Inilah bentuk utuh dari “General Number Field Sieve (GNFS)” yang mengumpulkan intisari matematika modern.

Apa Itu Matematika Terkuat Umat Manusia 'General Number Field Sieve (GNFS)' yang Membobol Kriptografi Internet?

Sat, 05 Sep 2026 02:09:08 +0900

Apa Itu Matematika Terkuat Umat Manusia “General Number Field Sieve (GNFS)” yang Membobol Kriptografi Internet?

Internet yang kita gunakan setiap hari. Semua komunikasi, seperti pesan LINE, YouTube, dan belanja di Amazon, dilindungi oleh “kriptografi”. Saat ini, kriptografi yang paling banyak digunakan di dunia adalah “Sandi RSA”.

Inti dari pertahanan Sandi RSA sangatlah sederhana. Ia memanfaatkan sifat matematika bahwa “faktorisasi prima dari angka yang sangat besar tidak dapat dipecahkan bahkan oleh komputer sekalipun” . Sebagai contoh, untuk “15”, kita langsung tahu bahwa itu adalah “3 × 5”, tetapi saat angkanya menjadi “270 digit”, menggabungkan seluruh superkomputer di dunia pun akan memakan waktu ratusan juta tahun untuk memecahkannya.

Namun, para matematikawan tidak tinggal diam. Untuk menembus pertahanan sandi yang tak tertembus ini, umat manusia telah menciptakan sebuah algoritma (prosedur perhitungan) ajaib yang disebut “General Number Field Sieve (GNFS)” .

Dalam artikel ini, tanpa menggunakan istilah teknis sama sekali, hanya dengan pengetahuan matematika sekolah menengah pertama (faktorisasi prima, aljabar, faktor persekutuan terbesar) , kami akan menjelaskan langkah demi langkah secara lengkap bagaimana “algoritma terkuat umat manusia” ini memecahkan sandi!

Bab 1: Tujuan Dekripsi adalah “Rumus Kelas 3 SMP”

Jurus andalan terbesar untuk menghadapi faktorisasi prima angka raksasa. Itu adalah rumus yang dipelajari di kelas 3 SMP ini.

$X^2 - Y^2 = (X + Y)(X - Y)$

Mungkin Anda berpikir, “Hah, rumus dasar seperti ini bisa memecahkan sandi?”. Namun, inilah kunci utama yang mengungkap segalanya.

Tujuan utama untuk memecahkan sandi adalah, terhadap angka raksasa $N$, menemukan “angka ($X$ dan $Y$) di mana sisa pembagian $X^2$ dan $Y^2$ oleh $N$ adalah sama” .

Mengapa “Sisa yang Sama” Dapat Memecahkan Sandi?

Misalkan dua angka, $X^2$ dan $Y^2$, memiliki “sisa yang sama jika dibagi dengan $N$”. Sisa yang sama berarti, hasil pengurangannya yaitu "$X^2 - Y^2$" pasti bisa dibagi habis oleh $N$ (merupakan kelipatan $N$) .

Di sini, mari asumsikan angka raksasa $N$ yang digunakan dalam sandi terbentuk dari perkalian dua bilangan prima rahasia ($p$ dan $q$) ($N = p \times q$).

Jika $X^2 - Y^2$ difaktorkan, hasilnya adalah $(X - Y)(X + Y)$ . Fakta bahwa ini adalah kelipatan $N$ berarti di suatu tempat dalam perkalian ini tersembunyi bilangan prima rahasia $p$ dan $q$.

Keajaiban terjadi di sini. Probabilitas secara matematis bahwa dua bilangan prima $p$ dan $q$ akan masuk ke ruangan yang berbeda, yaitu "$p$ ke ruangan $(X - Y)$" dan “$q$ ke ruangan $(X + Y)$” , adalah 50% (setengah) .

Dengan asumsi hanya bilangan prima $p$ yang masuk ke ruangan $(X - Y)$, mari kita hitung “faktor persekutuan terbesar (komponen terbesar yang sama)” dari $(X - Y)$ dan $N$.

Isi $(X - Y)$ = $p \times$ angka tertentu
Isi $N$ = $p \times q$ Satu-satunya komponen yang sama adalah "$p$" !

Artinya, saat kita menghitung faktor persekutuan terbesar, bilangan prima rahasia $p$ akan langsung terungkap, dan sandi akan berhasil dipecahkan sepenuhnya. (Faktor persekutuan terbesar bisa dihitung dalam sekejap bahkan menggunakan ponsel dengan “Algoritma Euclidean”)

[Kolom Singkat: Mengapa Pangkat Dua? Pangkat Tiga atau Dikali Dua Tidak Bisa?]

Jika “$2X - 2Y$”, hasilnya adalah $2(X - Y)$, sehingga hanya ada satu ruangan dan bilangan prima tidak dapat dipisahkan. Jika “$X^3 - Y^3$”, ukuran ruangan akan tidak seimbang, sehingga perhitungan menjadi sia-sia dan berat. Untuk memisahkan dua bilangan prima, membaginya dengan indah menjadi dua ruangan “pangkat dua” adalah yang paling efisien.

Bab 2: Bagaimana Mencari X dan Y? “Teka-teki Mengumpulkan Kartu Bilangan Prima”

Tujuannya sudah jelas. Namun, jika kita menebak-nebak mencari “$X^2$ dan $Y^2$ yang sisanya sama”, kita tidak akan menemukannya sampai alam semesta kiamat. Oleh karena itu, matematikawan memikirkan metode jenius yang disebut “Teka-teki Mengumpulkan Kartu Bilangan Prima” .

Langkah 1: Menyaring dan Mengumpulkan Hanya Serbuk Emas (Angka yang Halus)

Pertama, siapkan angka sembarang $Z$, kuadratkan, dan hitung sisa $W$ ketika dibagi $N$. (Dunia sisa dari $Z^2 = W$)

Faktorkan sisa $W$ yang muncul. Di sini, hanya jika muncul "$W$ yang hanya terdiri dari bilangan prima kecil seperti 2, 3, 5, 7" , kita simpan persamaan tersebut sebagai “kartu pemenang”, dan membuangnya jika ada bilangan prima besar yang tercampur. Ini seperti menyaring batu-batu besar di sungai dan hanya mengumpulkan serbuk emas.

Langkah 2: Teka-teki Membuat Semua Berjumlah “Genap”

Misalnya, terkumpul tiga kartu serbuk emas berikut.

Kartu A: $Z_1^2 = 2^3 \times 3^1$
Kartu B: $Z_2^2 = 2^1 \times 5^1$
Kartu C: $Z_3^2 = 3^1 \times 5^1$

Mari kita kalikan semuanya. Sisi kanan menjadi $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, jika disederhanakan menjadi "$2^4 \times 3^2 \times 5^2$" .

Luar biasa, jumlah bilangan prima menjadi “4, 2, 2”, semuanya berjumlah genap ! Jika semuanya genap, berarti kita bisa membagi dua jumlahnya untuk menjadikannya “pangkat dua dari sesuatu”. Artinya, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Karena sisi kiri adalah $(Z_1 \times Z_2 \times Z_3)^2$, akhirnya kita mendapatkan, $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ Pasangan “$X^2 = Y^2$” yang ditunggu-tunggu pun selesai!

Bagi komputer, memecahkan teka-teki apakah jumlah bilangan prima “genap atau ganjil (0 atau 1)” adalah hal yang sangat mudah, jadi dengan metode ini $X$ dan $Y$ bisa ditemukan dengan sangat cepat.

Bab 3: Tembok Keputusasaan yang Menghadang

Dengan ini semua sandi bisa dipecahkan! …begitulah yang dipikirkan, hingga sebuah masalah besar muncul. Jika angka sandi $N$ berukuran hingga sekitar “100 digit”, metode ini (disebut Quadratic Sieve) bisa menyelesaikannya. Namun, jika $N$ menjadi “200 digit atau 300 digit”, nilai $W$ yang muncul di tengah perhitungan menjadi terlalu besar.

Jika angkanya terlalu besar, “angka yang hanya terdiri dari bilangan prima kecil (serbuk emas)” akan berhenti muncul. Ini menjadi lebih sulit daripada mencari lensa kontak di padang pasir, dan kita tidak bisa mengumpulkan kartu sama sekali untuk memecahkan teka-teki.

Di sinilah akhirnya senjata pamungkas umat manusia, “General Number Field Sieve (GNFS)” , muncul.

Bab 4: Ide Terkuat Umat Manusia Membuat “Dua Dunia”

Ide jenius GNFS adalah, “Karena kita hanya menghitung di dunia nyata, angkanya menjadi besar. Kalau begitu, mari buat ‘dunia di balik layar’ menggunakan polinomial (aljabar), dan bagi beban perhitungannya menjadi dua” .

Keajaiban Aljabar

GNFS mengubah angka raksasa $N$ menjadi bentuk aljabar menggunakan angka dasar $m$. Misalnya, jika $N=100$, dengan $m=4$, maka $100 = 4^3 + 2(4^2) + 4$. Menggunakan huruf $x$, ini diubah menjadi persamaan (dunia balik layar) $f(x) = x^3 + 2x^2 + x$ .

Hal yang menarik dari persamaan ini adalah sifatnya: “Jika huruf $x$ disubstitusi dengan $m$ (4 dalam contoh di atas), ia akan selalu melesat kembali ke angka dunia nyata $N$” .

Mencari Serbuk Emas di Dua Dunia Sekaligus

GNFS membuat banyak pasangan bilangan bulat sembarang $(a, b)$, dan melakukan dua perhitungan berikut secara bersamaan.

Dunia nyata: $a - b \times m$
Dunia aljabar: Nilai perhitungan $a - b \times x$ berdasarkan aturan aljabar

Dengan membagi masalah ke dalam dua dunia, ukuran angka yang ditangani berkurang (menjadi lebih ringan) secara drastis. Bayangkan memecah batu raksasa menjadi dua batu kecil yang mudah dikelola.

Kemudian, dengan menggunakan saringan, kumpulkan HANYA pasangan $(a, b)$ ajaib di mana “Baik di dunia nyata maupun di dunia aljabar, keduanya ‘hanya terdiri dari bilangan prima kecil (serbuk emas)’” . Inilah asal mula nama “Number Field Sieve”.

Saat Sandi Akhirnya Dipecahkan

Ketika puluhan juta “kartu serbuk emas” dari kedua dunia terkumpul, gunakan kalkulasi matriks raksasa dari superkomputer untuk menemukan “kombinasi di mana semua jumlah bilangan prima genap”, persis seperti di Bab 2.

Setelah kombinasi ditemukan,

Jadikan angka pangkat dua yang terbentuk di dunia nyata sebagai $X^2$
Jadikan rumus pangkat dua yang terbentuk di dunia aljabar sebagai $Y(x)^2$

Terakhir, substitusikan $x$ dalam $Y(x)$ dari dunia aljabar dengan $m$, memindahkan dan menggabungkannya ke dunia nyata. Lalu, seperti keajaiban matematika, kondisi “sisa pembagian $X^2$ dan $Y^2$ sama” akan terbentuk dengan sempurna!

Setelah itu, seperti di Bab 1, dengan menghitung faktor persekutuan terbesar dari $X - Y$ dan $N$, sandi RSA yang tak tertembus akan hancur lebur, dan bilangan prima rahasia akan terungkap.

Penutup: Matematika Tidak Berakhir

Anda mungkin berpikir, “Bagus, dengan GNFS sandi apapun bisa dipecahkan!”. Namun, sandi RSA tidak menyerah begitu saja. Sandi yang digunakan di internet saat ini adalah angka raksasa mengerikan yang disebut “RSA-2048 (sekitar 617 digit)”.

Meskipun GNFS adalah algoritma terkuat umat manusia, bahkan untuk memecahkan 270 digit (RSA-270) sekalipun, dikatakan akan memakan waktu ribuan hingga puluhan ribu tahun meskipun seluruh komputer di dunia digabungkan. Untuk saat ini, data LINE dan bank kita aman.

Namun, apa yang akan terjadi jika muncul “keajaiban yang bisa menemukan $X$ dan $Y$ dalam sekejap untuk angka sebesar apa pun” ? Sebenarnya, entitas terdekat dengan hal tersebut saat ini sedang dalam pengembangan, yaitu “Komputer Kuantum (Algoritma Shor)” . Telah dibuktikan secara matematis bahwa dengan menggunakan sifat gelombang mekanika kuantum, teka-teki pengumpulan kartu yang merepotkan dapat dilewati untuk menarik jawaban sekaligus.

Persaingan kecerdasan yang tiada akhir antara pembuat sandi (pertahanan) dan pembuat algoritma pemecah sandi (serangan). Mengetahui bahwa “faktorisasi prima” dan “aljabar” yang dipelajari di SMP sebenarnya adalah senjata yang saling bertabrakan di garis depan keamanan dunia, bukankah kelas matematika sekarang terlihat sedikit lebih menarik?

Orang yang menemukan algoritma terkuat di masa depan, mungkin saja adalah Anda yang sedang membaca artikel ini!

(※Artikel ini mengonsepkan daya tarik matematis dari pemecahan sandi untuk pelajar SMP. GNFS yang sebenarnya dihitung secara ketat menggunakan matematika universitas tingkat lanjut seperti grup kelas ideal dari medan aljabar dan homomorfisme)