Kriptografi on kenji.blog

[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)

Prinsip Kerckhoffs

Wed, 16 Apr 2025 23:53:08 +0900

Prinsip Kerckhoffs

Halo!

Hari ini saya ingin membicarakan tentang sesuatu yang cukup menarik dan sebenarnya sangat penting, yaitu “Prinsip Kerckhoffs”.

Oh, tunggu sebentar.
Mungkin ada di antara Anda yang berpikir, “Saya belum pernah mendengar tentang ‘Prinsip Kerckhoffs’ dan kedengarannya terlalu rumit…” Tenang saja. Artikel ini justru ditujukan untuk Anda yang merasa demikian.

Apa maksud dari “Kriptografi yang Aman”?

Misalnya, seseorang mendatangi Anda dan berkata, “Brankas ini hanya bisa dibuka oleh orang yang mengetahui rahasianya.”

Sekilas, itu terdengar sangat aman, bukan?
Namun, jika dipikir-pikir lagi, bukankah itu sedikit mengkhawatirkan?

Seperti, “Jika rahasia itu terungkap, habislah sudah, kan?”

Sebenarnya, inilah alasan mengapa Prinsip Kerckhoffs diperkenalkan.

Apa itu sebenarnya “Prinsip Kerckhoffs”?

Secara singkat, ini adalah:

Pemikiran bahwa “Kriptografi harus tetap aman meskipun mekanismenya terungkap” .

Lebih tepatnya, “Keamanan hanya boleh bergantung pada ‘kunci rahasia’, dan tidak masalah jika metode enkripsi itu sendiri dipublikasikan!”

Sebaliknya, “Sistem yang hanya mengandalkan kerahasiaan algoritma (mekanisme) enkripsinya dianggap memiliki keandalan yang rendah.”

“Aman asalkan mekanismenya rahasia” mungkin sedikit berbahaya

Cara berpikir seperti ini sangat umum:

“Saya tidak menunjukkan isi aplikasi ini kepada siapa pun, jadi keamanannya terjamin.”

Saya mengerti perasaan itu.
Tetapi, itu sama saja dengan mengatakan, “Karena tidak ada yang melihatnya, tidak ada celah yang ditemukan, jadi pasti aman, kan?”

Pada kenyataannya, fakta bahwa “tidak ada yang melihat” itu sendiri bisa menjadi sebuah risiko.

Tetapi, mengapa prinsip seperti itu penting?

Alasannya adalah, jika seseorang mendapatkan mekanismenya dan dapat memecahkannya dengan mudah, maka kriptografi tersebut gagal.

Sebagai analogi, bayangkan sebuah kunci pintu yang memiliki mekanisme yang sangat rumit, tetapi sebenarnya bisa dibuka dengan kunci duplikat yang dibuat di toko murah.

Bukan “Aman karena kuncinya rahasia”, tetapi yang penting adalah “Bahkan jika seluruh mekanismenya diperlihatkan, tidak akan bisa dibuka tanpa kunci yang tepat.”

Perasaan “Tapi, bukankah itu menakutkan?”

Hal yang dirasakan oleh banyak orang di sini adalah,

“Mengekspos seluruh mekanisme, bukankah itu agak menakutkan?”

Saya mengerti kecemasan tersebut.

Karena Anda pasti akan berpikir, “Jika saya menunjukkan semuanya, bukankah itu akan ditiru atau disalahgunakan?”

Namun, justru di situlah letak inti dari Prinsip Kerckhoffs.
“Kekuatan yang tidak hancur meskipun isinya diperlihatkan” itulah keamanan yang sesungguhnya.

Meskipun begitu, butuh sedikit keberanian pada awalnya

Jika mencoba menempatkan diri sebagai pengembang, “Mempublikasikan mekanisme = kelemahan juga terlihat”, tentu saja itu mendebarkan.

Tapi coba pikirkan.

Sesuatu yang secara terbuka menunjukkan mekanismenya dan mengatakan, “Siapa pun boleh memverifikasinya,” pada akhirnya akan lebih dipercaya.

Itu mirip dengan hubungan antar manusia, bukan?

“Seseorang yang menunjukkan jati dirinya dan tetap berteman dengan baik”, tentu saja adalah yang paling bisa membuat kita merasa tenang.

Jadi begitulah

Prinsip Kerckhoffs mungkin terdengar sedikit teoritis, namun esensinya sangat sederhana.

Hanya masalah “Mari kita buat mekanisme yang tidak akan rusak tidak peduli siapa yang melihatnya” .

Desain yang tepat lebih dari sekadar rahasia yang dangkal.
Kode yang tidak memalukan untuk ditunjukkan, lebih baik daripada kode yang tidak ingin Anda tunjukkan kepada siapa pun.

“Kekuatan” seperti itu mungkin akan semakin dibutuhkan di era mendatang.

Terima kasih sudah membaca!

Topik keamanan mungkin sedikit sulit, tetapi ada bagian yang terhubung dengan “hubungan manusia” dan “rasa aman sehari-hari”.
Saya yakin jika Anda mempelajarinya sedikit demi sedikit tanpa merasa terbebani, akan ada hal baik yang terjadi.