Kriptografi on kenji.blog

【Penjelasan Matematika】Menjelaskan Cara Kerja Enkripsi RSA Agar Dapat Dipahami Bahkan oleh Siswa SMA

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

Salah satu teknologi yang mendasari keamanan masyarakat internet adalah “Enkripsi RSA”. Sebagian besar komunikasi yang kita gunakan tanpa disadari setiap hari, seperti pembayaran kartu kredit dalam belanja online, interaksi di media sosial dengan teman, dan transmisi serta penerimaan informasi rahasia perusahaan, dilindungi oleh enkripsi RSA ini atau teknologi penerusnya.

Namun, ketika mendengar kata “kriptografi”, Anda mungkin membayangkan mesin sandi yang rumit seperti yang ada di film mata-mata, atau matematika tingkat sangat tinggi yang hanya dapat dipahami oleh sebagian kecil orang jenius. Memang benar bahwa teori kriptografi modern didasarkan pada matematika tingkat tinggi, tetapi mekanisme dasar dari enkripsi RSA dapat dipahami dengan baik jika Anda memiliki pengetahuan matematika yang dipelajari di sekolah menengah atas (sifat bilangan bulat, bilangan prima, aritmetika modular (kongruensi), dll.).

Dalam artikel ini, dengan pengetahuan matematika sekolah menengah atas sebagai titik awal, kami akan menjelaskan secara menyeluruh selangkah demi selangkah prinsip matematika apa yang membuat enkripsi RSA bekerja dan mengapa sulit untuk dipecahkan. Kami akan menjelaskannya dengan hati-hati disertai contoh-contoh konkret sehingga bahkan mereka yang kurang ahli dalam matematika dapat memahaminya.

1. Kriptografi Kunci Simetris dan Kriptografi Kunci Publik

Sebelum masuk ke mekanisme matematis dari enkripsi RSA, mari kita perjelas konsep dasar dari kriptografi terlebih dahulu. Sistem kriptografi secara garis besar dibagi menjadi dua jenis: “kriptografi kunci simetris” dan “kriptografi kunci publik”.

1.1 Keterbatasan Sistem Kriptografi Kunci Simetris

Banyak kriptografi yang telah digunakan sejak zaman dahulu disebut “sistem kriptografi kunci simetris”. Ini adalah sistem yang menggunakan kunci yang sama untuk “enkripsi (mengubah pesan menjadi teks sandi rahasia)” dan “dekripsi (mengembalikan teks sandi ke pesan aslinya)”.

Sebagai contoh, misalkan Alice mengirim surat rahasia kepada Bob. Alice memasukkan surat itu ke dalam kotak dan menguncinya menggunakan gembok (kunci simetris). Agar Bob bisa membuka kotak tersebut, ia harus memiliki kunci yang sama dengan yang digunakan Alice.

Ada masalah besar dengan sistem ini. Yakni “masalah distribusi kunci”. Ketika Alice dan Bob, yang berjauhan, berkomunikasi untuk pertama kalinya, bagaimana mereka bisa berbagi kunci tanpa disadap? Jika kunci tersebut dicuri oleh pihak ketiga saat dikirim melalui pos, semua komunikasi terenkripsi setelahnya akan sepenuhnya bocor.

1.2 Penemuan Revolusioner “Sistem Kriptografi Kunci Publik”

Untuk menyelesaikan masalah distribusi kunci ini, “sistem kriptografi kunci publik” diciptakan. Enkripsi RSA adalah salah satu jenisnya.

Dalam sistem kriptografi kunci publik, dua kunci yang berbeda digunakan: “kunci untuk enkripsi (kunci publik)” dan “kunci untuk dekripsi (kunci privat/rahasia)”.

Penerima, Bob, membuat sepasang “kunci publik” dan “kunci privat”.
Bob mempublikasikan “kunci publik”-nya ke seluruh dunia (tidak masalah siapa pun yang mendapatkannya).
Pengirim, Alice, menggunakan “kunci publik” Bob untuk mengenkripsi pesan dan mengirimkannya.
Pesan yang terenkripsi hanya bisa didekripsi dengan “kunci privat” yang hanya dimiliki oleh Bob.

Jika diibaratkan dengan gembok, Bob membuat banyak “gembok yang terbuka (kunci publik)” dan menyebarkannya ke seluruh dunia. Alice memasukkan pesan yang ditujukan kepada Bob ke dalam kotak, dan menguncinya dengan klik menggunakan gembok Bob yang ia temukan. Begitu gembok ditutup, ia hanya dapat dibuka dengan “kunci master (kunci privat)” yang dimiliki oleh Bob. Bahkan jika seseorang mencuri kotak itu di tengah jalan, mereka tidak bisa membukanya karena tidak memiliki kunci master.

graph TD A["Alice (Pengirim)"] --> B["Teks Terang (Pesan)"] B --> C["Proses Enkripsi"] D["Kunci Publik Bob (Tersedia untuk siapa saja)"] --> C C --> E["Dikirim via Internet: Teks Sandi"] E --> F["Proses Dekripsi"] G["Kunci Privat Bob (Hanya dimiliki Bob)"] --> F F --> H["Teks Terang Dipulihkan (Pesan)"] H --> I["Bob (Penerima)"]

Untuk mewujudkan sistem revolusioner ini, diperlukan semacam “fungsi satu arah (teka-teki matematika satu arah)” yang “mudah dienkripsi dengan kunci publik, tetapi sama sekali tidak dapat didekripsi tanpa kunci privat”. Yang menjadi perhatian sebagai bagian dari teka-teki itu adalah “bilangan prima” yang sering kita kenal.

2. Dasar Matematika yang Mendukung Enkripsi RSA 1: Bilangan Prima dan Faktorisasi Prima

Keamanan enkripsi RSA didasarkan pada fakta matematis bahwa “faktorisasi prima dari bilangan yang sangat besar adalah sangat sulit”.

2.1 Apa itu Bilangan Prima?

Bilangan prima adalah “bilangan asli lebih besar dari 1 yang hanya bisa dibagi habis oleh 1 dan dirinya sendiri”. Contoh: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Bilangan prima itu seperti “atom” untuk semua bilangan bulat. Bilangan asli apa pun bisa diuraikan ke dalam bentuk perkalian bilangan-bilangan prima. Ini disebut faktorisasi prima. Sebagai contoh, $60 = 2^2 \times 3 \times 5$, dapat difaktorisasi prima hanya dalam satu cara dengan mengabaikan urutan, hal ini dikenal sebagai “Teorema Dasar Aritmetika”.

2.2 Kesulitan Faktorisasi Prima (Fungsi Satu Arah)

Yang penting di sini adalah asimetri di mana “perkalian itu mudah, tetapi faktorisasi prima itu sulit”.

Sebagai contoh, coba hitung perkalian dua bilangan prima berikut di luar kepala. $11 \times 13 = ?$ Ini mudah, bukan? Jawabannya adalah $143$.

Lalu, bagaimana dengan bilangan berikut? Faktorisasi prima dari $323$. Bagaimana? Seharusnya butuh sedikit waktu. (Jawabannya adalah $17 \times 19$).

Jika bilangannya kecil, manusia masih bisa menghitungnya entah bagaimana, tetapi ketika bilangannya menjadi besar, penghitungannya akan sangat sulit bahkan dengan menggunakan komputer. Enkripsi RSA mainstream saat ini menggunakan bilangan $N = p \times q$ yang mengalikan bilangan prima yang sangat besar $p$ dan $q$ sebesar 2048 bit (sekitar 600 digit dalam desimal).

Diberikan dua bilangan prima raksasa $p$ dan $q$, menghitung $N$ membutuhkan waktu sekejap (kurang dari milidetik) bagi komputer. Namun sebaliknya, jika hanya diberikan $N$ untuk mencari tahu $p$ dan $q$ yang asli, akan memakan waktu yang sangat lama yang tidak dapat dipecahkan bahkan jika superkomputer tercepat saat ini dijalankan selama triliunan tahun.

Inilah “asimetri komputasi (mudah satu arah, sulit arah sebaliknya)” yang menjadi landasan untuk menciptakan hubungan antara kunci publik dan kunci privat.

3. Dasar Matematika yang Mendukung Enkripsi RSA 2: Kongruensi (Aritmetika Modular)

Perhitungan enkripsi RSA tidak dilakukan dengan penjumlahan atau perkalian bilangan yang menjadi besar tanpa batas seperti yang biasa kita gunakan, melainkan dalam dunia “sisa” setelah dibagi dengan suatu bilangan tertentu. Ini disebut kongruensi (aritmetika modular).

3.1 Matematika Jam

Aritmetika modular sering diibaratkan sebagai “matematika jam”. Misalkan sekarang jam 10, jam berapakah 5 jam dari sekarang? $10 + 5 = 15$, namun pada jam 12 jam biasa kita akan menjawab “jam 3”. Hal ini karena sisa dari 15 dibagi 12 adalah 3.

Dalam dunia matematika, ini ditulis sebagai berikut.

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

Ini dibaca sebagai “15 dan 3 adalah kongruen modulo 12 (sisanya sama jika dibagi 12)”.

3.2 Sifat Dasar Kongruensi

Kongruensi memiliki sifat-sifat yang sangat berguna yang mirip dengan persamaan ($=$). Misalkan modulo (pembagi)-nya adalah $N$. Jika $a \equiv b \pmod N$ dan $c \equiv d \pmod N$, maka hal-hal berikut ini berlaku:

Penjumlahan: $a + c \equiv b + d \pmod N$
Pengurangan: $a - c \equiv b - d \pmod N$
Perkalian: $a \times c \equiv b \times d \pmod N$
Perpangkatan: $a^k \equiv b^k \pmod N$ (di mana $k$ adalah bilangan asli)

Yang paling penting adalah sifat “perpangkatan”. Ini berarti “sisa pembagian suatu perpangkatan sama dengan perpangkatan dari sisa pembagian”. Misalnya, misalkan kita ingin mencari sisa dari $7^{100}$ dibagi $5$. Jika kita serius mengalikan $7$ seratus kali dan kemudian membaginya dengan $5$, itu akan sangat sulit, tetapi menggunakan sifat kongruensi, karena $7 \equiv 2 \pmod 5$, maka akan menjadi $7^{100} \equiv 2^{100} \pmod 5$, yang menyederhanakan perhitungan secara drastis. Sifat ini sangat penting dalam dunia kriptografi karena berkaitan dengan perpangkatan angka yang sangat besar.

4. Dasar Matematika yang Mendukung Enkripsi RSA 3: Fungsi Euler dan Teorema Euler

Mulai dari sini, kita masuk ke inti keajaiban matematika dari enkripsi RSA. Muncullah “Teorema Euler” yang merupakan generalisasi dari “Teorema Kecil Fermat”.

4.1 Fungsi Totient Euler $\phi(N)$

Fungsi Totient Euler (Fungsi $\phi$) adalah fungsi yang untuk suatu bilangan asli $N$, menghasilkan “jumlah bilangan dari bilangan asli antara 1 hingga $N$ yang saling prima (faktor persekutuan terbesarnya adalah 1) dengan $N$”.

Mari kita lihat beberapa contoh.

$\phi(5)$: Di antara 1, 2, 3, 4, 5, bilangan yang saling prima dengan 5 ada 4 bilangan yaitu 1, 2, 3, 4. Sehingga, $\phi(5) = 4$.
$\phi(6)$: Di antara 1, 2, 3, 4, 5, 6, bilangan yang saling prima dengan 6 ada 2 bilangan yaitu 1, 5. Sehingga, $\phi(6) = 2$.

【Sifat Khusus dalam Kasus Bilangan Prima】 Jika $p$ adalah bilangan prima, semua angka dari 1 hingga $p-1$ akan saling prima dengan $p$. Oleh karena itu,

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

【Sifat Khusus dalam Kasus Hasil Kali Bilangan Prima】 Untuk dua bilangan prima berbeda $p$ dan $q$, jika $N = p \times q$, $\phi(N)$ dapat dengan mudah dicari melalui perhitungan berikut.

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

Sifat ini berfungsi sebagai “pintu belakang rahasia (trapdoor)” dari enkripsi RSA. Seseorang yang mengetahui $p$ dan $q$ (pembuat kunci) dapat menghitung $\phi(N)$ dalam sekejap, tetapi pihak ketiga yang hanya tahu $N$ tidak akan bisa mencari $\phi(N)$ kecuali mereka memfaktorkan prima $N$.

4.2 Teorema Euler

Leonhard Euler menggunakan $\phi(N)$ ini untuk membuktikan teorema yang indah sebagai berikut.

Teorema Euler: Ketika bilangan bulat $a$ dan $N$ saling prima, persamaan kongruensi berikut berlaku.

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

Ini adalah sifat yang luar biasa, yang menyatakan bahwa “jika suatu bilangan $a$ dikalikan $\phi(N)$ kali lalu dibagi $N$, sisanya pasti akan menjadi $1$”. (Jika $N$ adalah bilangan prima $p$, ia menjadi $a^{p-1} \equiv 1 \pmod p$ dan disebut Teorema Kecil Fermat).

Mari kita ubah bentuk Teorema Euler ini. Kita kalikan kedua sisi dengan $a$ sekali lagi.

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

Lebih lanjut, untuk sembarang bilangan bulat $k$, $a^{k \cdot \phi(N)}$ juga menjadi $1^k = 1$, sehingga persamaan berikut berlaku.

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

Persamaan inilah prinsip fundamental yang mewujudkan keajaiban enkripsi RSA yaitu “setelah dienkripsi dan kemudian didekripsi akan kembali ke asalnya”.

5. Algoritma Enkripsi RSA: Langkah Pembuatan Kunci, Enkripsi, dan Dekripsi

Sekarang setelah kita memiliki pengetahuan dasarnya, mari kita lihat prosedur spesifik dari enkripsi RSA. Enkripsi RSA dibagi menjadi 3 fase utama: “1. Pembuatan Kunci”, “2. Enkripsi”, dan “3. Dekripsi”.

flowchart TD A1["1. Pilih bilangan prima p, q"] --> A2["Hitung N = p × q"] A1 --> A3["Hitung φ(N) = (p-1)(q-1)"] A3 --> A4["Pilih e yang saling prima dengan φ(N)"] A3 --> A5["Hitung d sehingga e × d ≡ 1 (mod φ(N))"] A2 --> A6["Kunci Publik (N, e)"] A4 --> A6 A5 --> A7["Kunci Privat d"] B1["2. Pesan Teks Terang M"] --> B2["Hitung C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Kirim Teks Sandi C"] B3 --> C1["3. Teks Sandi C Diterima"] C1 --> C2["Hitung M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Dapatkan pesan teks terang awal M"]

5.1 Pembuatan Kunci (Key Generation)

Penerima, Bob, membuat “kunci publik” dan “kunci privat” untuk dirinya sendiri.

Pemilihan Bilangan Prima: Pilih dua bilangan prima besar $p$ dan $q$ secara acak.
Perhitungan Modulo $N$: Hitung $N = p \times q$. Nilai $N$ ini akan dipublikasikan.
Perhitungan $\phi(N)$: Hitung fungsi Euler $\phi(N) = (p - 1)(q - 1)$. Ini adalah angka rahasia milik Bob.
Pemilihan Kunci Publik $e$: Pilih bilangan bulat $e$ dengan syarat $1 < e < \phi(N)$ dan saling prima dengan $\phi(N)$.
Perhitungan Kunci Privat $d$: Temukan bilangan bulat $d$ yang memenuhi syarat berikut: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Artinya, “suatu bilangan $d$ sedemikian rupa sehingga jika $e \times d$ dibagi $\phi(N)$, sisanya adalah $1$”.

Kini kunci sudah siap.

Kunci Publik: Pasangan $(N, e)$. Dipublikasikan ke seluruh dunia.
Kunci Privat: $d$. Sama sekali tidak diberitahukan kepada siapa pun.

5.2 Enkripsi (Encryption)

Misalkan Alice ingin mengirim pesan rahasia $M$ kepada Bob. (Misalkan $M$ adalah nilai numerik dari teks, dengan $0 \le M < N$). Alice menggunakan kunci publik Bob $(N, e)$ untuk menghitung hal berikut.

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

Menghitung “pesan $M$ dipangkatkan dengan $e$, dan sisanya setelah dibagi dengan $N$ adalah $C$”. $C$ ini adalah teks sandinya.

5.3 Dekripsi (Decryption)

Bob menerima teks sandi $C$. Bob menggunakan kunci privatnya $d$ untuk menghitung hal berikut.

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

Jika “teks sandi $C$ dipangkatkan dengan $d$, dan dihitung sisanya setelah dibagi dengan $N$”, menakjubkan sekali, pesan asli $M$ berhasil dipulihkan!

6. Mengapa Bisa Kembali Asal Melalui Dekripsi? (Pembuktian Matematis)

Anda mungkin bertanya-tanya, “Bagaimana mungkin hanya dengan memangkatkan $C$ dengan $d$ bisa mengembalikannya ke $M$ yang asli?”. Di sinilah “Teorema Euler” yang sudah dibahas sebelumnya menunjukkan kekuatannya.

Mari kita substitusikan rumus enkripsi $C = M^e$ ke dalam rumus dekripsi $C^d \pmod N$.

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

Sekarang, ingatlah langkah 5 pada pembuatan kunci. Saat Bob membuat $d$, ia memilihnya sedemikian rupa sehingga $e \times d \equiv 1 \pmod{\phi(N)}$. Ini berarti bahwa “$ed$ adalah kelipatan $\phi(N)$ ditambah $1$”. Kita bisa menuliskannya menggunakan bilangan bulat $k$ seperti ini:

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

Kita substitusikan ini ke eksponen, dan menjabarkannya menggunakan hukum eksponen.

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

Di sini, jika kita mengasumsikan bahwa pesan $M$ dan $N$ saling prima, menurut Teorema Euler maka $M^{\phi(N)} \equiv 1 \pmod N$.

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

Sehingga, terbukti bahwa persamaan berikut ini benar.

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

Alice tidak tahu $d$, dan penyadap juga tidak tahu $d$, jadi hanya Bob yang memiliki $d$ lah yang bisa mengekstrak $M$ dari $C$.

7. Contoh Konkret: Mari Mencoba RSA dengan Perhitungan Manual Menggunakan Bilangan Prima Kecil

Mari kita gunakan angka-angka (bilangan prima) kecil untuk mempraktekkan komunikasi terenkripsi dari Alice ke Bob.

【Fase Pembuatan Kunci oleh Bob】

Pilih dua bilangan prima $p=11$, $q=13$.
Hitung $N = 11 \times 13 = 143$.
Hitung $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Pilih kunci publik $e$ yang saling prima dengan $\phi(N)=120$. Di sini, kita buat $e=7$.
Cari kunci privat $d$. Kita cari $d$ yang mana $7 \times d \equiv 1 \pmod{120}$. Dalam persamaan $7d = 120k + 1$, saat $k=6$, hasilnya menjadi $721$, dan $721 \div 7 = 103$. Maka, $d = 103$.

Kunci Publik: $(N=143, e=7)$
Kunci Privat: $d=103$

【Fase Enkripsi oleh Alice】 Misalkan Alice ingin mengirim pesan $M = 9$. Rumus: $C \equiv 9^7 \pmod{143}$ $9^7 = 4.782.969$. Jika dibagi 143, hasil baginya 33.447 dengan sisa $48$. Teks sandinya menjadi $C = 48$.

【Fase Dekripsi oleh Bob】 Bob menerima teks sandi $C = 48$ dan menggunakan kunci privat $d = 103$ untuk mendekripsinya. Rumus: $M \equiv 48^{103} \pmod{143}$ Jika Anda mengeksekusi (48 ** 103) % 143 di kalkulator (atau komputer), hasilnya secara menakjubkan adalah “9”! Pesan asli berhasil diterima dengan aman.

8. Cara Mencari Kunci Privat $d$: Algoritma Euclidean Diperluas (Extended Euclidean Algorithm)

Pada contoh hitung manual, kita menebak nilai $k$ untuk mencari $d=103$, namun saat bilangannya menjadi ratusan digit, cara ini tidak mungkin dilakukan. Dalam program komputer yang nyata, digunakan algoritma yang disebut “Algoritma Euclidean Diperluas” (Extended Euclidean Algorithm).

Menyelesaikan $7d \equiv 1 \pmod{120}$ sama artinya dengan mencari bilangan bulat $d, y$ yang memenuhi $7d + 120y = 1$. Dengan menghitung balik Algoritma Euclidean, hal ini bisa didapatkan secara mekanis.

$120 \div 7 = 17$ sisa $1$
Jika kita ubah persamaannya, $1 = 120 - 17 \times 7$
Artinya, $-17 \times 7 \equiv 1 \pmod{120}$

$-17$ memiliki makna yang sama dengan $120 - 17 = 103$ dalam dunia modulo $120$. Oleh karena itu, $d = 103$ dapat ditemukan dalam sekejap. Cara ini dapat menghitung bilangan sebesar apa pun dengan sangat cepat.

9. Wajah Lain dari Enkripsi RSA: Tanda Tangan Digital

Hal hebat dari enkripsi RSA adalah, ia juga bisa digunakan sebagai “tanda tangan digital” dengan menukar peran kunci publik dan kunci privat.

Pada enkripsi: “Enkripsi dengan kunci publik $\Rightarrow$ Dekripsi dengan kunci privat”. Pada tanda tangan digital, prosedurnya menjadi: “Enkripsi dengan kunci privat $\Rightarrow$ Dekripsi dengan kunci publik”.

flowchart TD A1["1. Alice membuat tanda tangan dengan kunci privatnya"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Mengirim pesan M dan tanda tangan S"] A3 --> B1["2. Bob memverifikasi tanda tangan dengan kunci publik"] B1 --> B2["Menghitung M' ≡ S^e (mod N)"] B2 --> B3["Memeriksa apakah M' cocok dengan M"]

Alice menggunakan kunci privatnya sendiri $d$ untuk mengubah pesan (ini adalah tanda tangan $S$) dan mengirimkannya ke Bob. Bob menggunakan kunci publik Alice $e$ untuk melakukan perhitungan verifikasi. Jika hasil perhitungannya cocok dengan pesan asli, ini sekaligus membuktikan “bahwa data itu hanya bisa dibuat dengan kunci privat Alice” dan “pesan itu tidak dimanipulasi di tengah jalan”.

10. Merasakan Enkripsi RSA Melalui Program

Perhitungan perpangkatan yang berat jika dihitung manual dapat diimplementasikan dengan sangat mudah menggunakan Python. Berikut adalah kode Python untuk mengalami logika inti dari enkripsi RSA.

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


def gcd(a, b):
 """Mencari faktor persekutuan terbesar (FPB)"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Mencari kunci privat d (Menggunakan fungsi bawaan dari Python 3.8 ke atas)"""
 return pow(e, -1, phi)

# 1. Pembuatan Kunci
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Kunci Publik: (N={N}, e={e}), Kunci Privat: d={d}")

# 2. Enkripsi
message = 9
ciphertext = pow(message, e, N)
print(f"Teks Sandi: {ciphertext}")

# 3. Dekripsi
decrypted_message = pow(ciphertext, d, N)
print(f"Pesan yang Didekripsi: {decrypted_message}")

Fungsi pow(base, exp, mod) pada Python secara internal menggunakan algoritma cepat yang disebut “Exponensiasi Pengkuadratan Berulang” (Repeated Squaring), sehingga perhitungan selesai dalam sekejap bahkan jika angkanya ratusan digit.

11. Kesimpulan dan Teknologi Kriptografi Masa Depan

Berdasarkan pengetahuan matematika tingkat sekolah menengah atas, kita telah mengungkap cara kerja dari enkripsi RSA.

Kesulitan Faktorisasi Prima: Mudah untuk menghitung $p \times q = N$, tetapi sangat sulit untuk menemukan $p, q$ dari $N$.
Kongruensi dan Teorema Euler: Berkat aturan $a^{\phi(N)} \equiv 1 \pmod N$, sebuah trapdoor ajaib “memangkatkan dengan suatu bilangan mengembalikan ke bentuk asli” telah tercipta.
Kunci Publik dan Kunci Privat: Siapa pun dapat mengenkripsi, tetapi hanya penerima sah yang dapat mendekripsi.

Nilai $N$ pada enkripsi RSA yang digunakan saat ini lebih dari 600 digit, dan butuh waktu lebih lama dari usia alam semesta untuk memfaktorkan primanya meskipun dengan menggerakkan seluruh superkomputer di dunia. Namun, jika “komputer kuantum”, yang penelitiannya sedang berkembang dalam beberapa tahun terakhir, berhasil dikomersialkan di masa depan, ada kemungkinan bahwa faktorisasi prima ini akan dipecahkan dalam sekejap oleh algoritma Shor. Oleh karena itu, pengembangan “Kriptografi Pasca Kuantum” (Post-Quantum Cryptography) yang tidak dapat dipecahkan bahkan oleh komputer kuantum saat ini sedang dikembangkan dengan sangat cepat di seluruh dunia.

Matematika tingkat tinggi yang sering dianggap “tidak berguna”, nyatanya melindungi kehidupan sehari-hari kita dari fondasinya. Enkripsi RSA merupakan materi pembelajaran terbaik yang mengajarkan kita kedalaman dan keindahan matematika tersebut. Kami harap melalui artikel ini, Anda sedikit banyak dapat merasakan betapa menariknya kriptografi dan matematika.

Dasar Matematika Kriptografi Kurva Eliptik (ECC) dan Implementasinya dalam C++

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

Dasar Matematika Kriptografi Kurva Eliptik (ECC) dan Implementasinya dalam C++

Dalam teknologi kriptografi modern, Kriptografi Kurva Eliptik (Elliptic Curve Cryptography: ECC) memainkan peran yang sangat penting. Dari komunikasi internet harian kita (HTTPS/TLS), secure enclave di smartphone, autentikasi server melalui SSH, autentikasi tanpa kata sandi seperti FIDO, hingga aset kripto seperti Bitcoin dan Ethereum, tidak berlebihan untuk mengatakan bahwa fondasi kepercayaan masyarakat digital saat ini didukung oleh ECC.

Dalam artikel ini, kami akan menjelaskan secara menyeluruh dengan detail yang luar biasa tentang bagaimana kriptografi kurva eliptik ini berfungsi, mulai dari teori matematika yang indah namun rumit di baliknya (geometri aljabar di atas lapangan berhingga), metode implementasi aktual menggunakan C++, hingga teknik pengkodean yang aman untuk mencegah serangan saluran samping (serangan waktu).

1. Mengapa Kriptografi Kurva Eliptik? (Perbandingan dengan RSA)

Sinonim dari kriptografi kunci publik telah lama adalah kriptografi RSA. RSA mendasarkan keamanannya pada “kesulitan faktorisasi prima dari bilangan komposit yang sangat besar”. Namun, seiring dengan peningkatan kemampuan komputasi komputer, ada kebutuhan untuk terus memperpanjang panjang kunci (jumlah bit modulus) RSA untuk mempertahankan keamanannya. Saat ini, direkomendasikan setidaknya panjang kunci 2048 bit, atau 3072 bit hingga 4096 bit untuk keamanan yang lebih baik.

Sebaliknya, kriptografi kurva eliptik (ECC) mendasarkan keamanannya pada kesulitan matematika yang berbeda, yaitu “Masalah Logaritma Diskret Kurva Eliptik (ECDLP)”. Algoritma yang efisien untuk memecahkan ECDLP (seperti algoritma waktu sub-eksponensial) belum ditemukan hingga saat ini, dan bahkan metode serangan paling efisien yang diketahui memerlukan waktu eksponensial.

Karena sifat ini, ECC memiliki keuntungan krusial yaitu dapat mencapai tingkat keamanan yang setara dengan RSA namun dengan panjang kunci yang jauh lebih pendek.

Kekuatan Keamanan (bit)	Panjang Kunci RSA (bit)	Panjang Kunci Kriptografi Kurva Eliptik (bit)	Rasio Panjang Kunci
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Seperti yang ditunjukkan pada tabel di atas, untuk mendapatkan kekuatan keamanan 128 bit (kekuatan standar saat ini), RSA memerlukan kunci 3072 bit, sedangkan ECC hanya membutuhkan 256 bit. Hal ini memungkinkan pengurangan komputasi, penggunaan memori yang lebih rendah, dan penghematan bandwidth jaringan, yang memberikan keunggulan luar biasa terutama pada perangkat IoT dan lingkungan smart card dengan sumber daya terbatas.

2. Persiapan Matematika: Teori Grup dan Dunia Lapangan Berhingga

Untuk benar-benar memahami kriptografi kurva eliptik, penting untuk memahami konsep dasar aljabar abstrak (teori grup dan teori lapangan). Di sini, kami merangkum pengetahuan prasyarat untuk mengonstruksi ECC secara ringkas.

2.1. Grup (Group) dan Grup Abelian

Grup (Group) adalah himpunan $G$ yang dilengkapi dengan operasi biner (di sini kita gunakan penjumlahan $+$), disimbolkan dengan $(G, +)$, yang memenuhi 4 aksioma berikut:

Sifat Tertutup (Closure): Untuk setiap $a, b \in G$, maka $a + b \in G$.
Sifat Asosiatif (Associativity): Untuk setiap $a, b, c \in G$, berlaku $(a + b) + c = a + (b + c)$.
Eksistensi Elemen Identitas (Identity element): Terdapat elemen $e \in G$ sehingga untuk setiap $a \in G$, berlaku $a + e = e + a = a$. Dalam kasus grup aditif, elemen identitas ini biasanya dilambangkan dengan $0$ atau $\mathcal{O}$.
Eksistensi Elemen Invers (Inverse element): Untuk setiap $a \in G$, terdapat elemen $b \in G$ sehingga $a + b = b + a = e$. $b$ ini dilambangkan sebagai $-a$.

Lebih lanjut, jika urutan operasi diubah dan hasilnya tetap sama, yaitu memenuhi kondisi di bawah ini, grup tersebut disebut Grup Abelian (Grup Komutatif).

Sifat Komutatif (Commutativity): Untuk setiap $a, b \in G$, berlaku $a + b = b + a$.

Himpunan titik-titik pada kurva eliptik membentuk grup Abelian ini dengan mendefinisikan aturan penjumlahan tertentu.

2.2. Lapangan Berhingga (Finite Field)

Dalam teori kriptografi, kita tidak menggunakan lapangan dengan elemen yang kontinu dan tak terhingga seperti bilangan real atau bilangan kompleks, melainkan menggunakan Lapangan Berhingga (Finite Field) atau Lapangan Galois (Galois Field) yang jumlah elemennya terbatas.

Lapangan berhingga yang paling dasar adalah lapangan prima $\mathbb{F}_p$ menggunakan bilangan prima $p$. Ini adalah himpunan bilangan bulat $\{0, 1, 2, \dots, p-1\}$ yang dilengkapi dengan empat operasi aritmetika (penjumlahan, pengurangan, perkalian, pembagian) dengan modulo $p$ (sisa pembagian dengan $p$).

Penjumlahan: $(a + b) \pmod p$
Pengurangan: $(a - b) \pmod p$
Perkalian: $(a \times b) \pmod p$
Pembagian: $a \times b^{-1} \pmod p$ (di mana $b^{-1}$ adalah invers perkalian modulo $p$ dari $b$)

Penghitungan Invers Perkalian Modulo (Modular Multiplicative Inverse) sangat penting dalam implementasi kriptografi. Untuk menemukan $b^{-1}$ yang memenuhi $b \times b^{-1} \equiv 1 \pmod p$, dua algoritma berikut ini terutama digunakan:

Algoritma Euclidean Diperluas (Extended Euclidean Algorithm): Cepat, tetapi tergantung pada implementasinya, waktu pemrosesan dapat bergantung pada nilai input sehingga memiliki risiko serangan waktu.
Teorema Kecil Fermat (Fermat’s Little Theorem): Ketika $p$ adalah bilangan prima dan $b \neq 0$, berlaku $b^{p-1} \equiv 1 \pmod p$. Jika kedua sisi dibagi dengan $b$, maka diperoleh $b^{p-2} \equiv b^{-1} \pmod p$. Artinya, invers dapat dicari dengan menghitung pangkat $p-2$ dari $b$. Karena operasi pemangkatan mudah diimplementasikan dalam waktu konstan (constant time), metode ini lebih disukai dalam implementasi kriptografi.

3. Persamaan Kurva Eliptik dan Geometri

3.1. Bentuk Normal Weierstrass

Kurva Eliptik (Elliptic Curve) pada umumnya adalah kurva pada bidang datar yang didefinisikan oleh persamaan berikut, yang disebut bentuk normal Weierstrass (Weierstrass normal form).

$$ y^2 = x^3 + ax + b $$

Di sini, $a$ dan $b$ adalah konstanta, dan agar kurva tidak memiliki titik singular (seperti persimpangan mandiri atau titik puncak) (yakni, kurvanya mulus), nilai Diskriminan (Discriminant) $\Delta$ berikut disyaratkan tidak boleh nol.

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

Karena kurva yang memiliki titik singular dapat merusak keamanan kriptografi, koefisien $a, b$ yang memenuhi kondisi ini selalu dipilih.

3.2. Titik di Tak Terhingga (Point at Infinity)

Untuk menjadikan kurva eliptik sebagai grup yang sempurna secara matematis, titik virtual yang disebut “Titik di Tak Terhingga (Point at Infinity)” diperkenalkan selain titik-titik pada bidang datar. Titik ini dilambangkan sebagai $\mathcal{O}$ (O besar).

Titik di tak terhingga $\mathcal{O}$ didefinisikan sebagai titik tempat semua garis vertikal bertemu di tempat yang tak terhingga. Dalam teori grup, titik di tak terhingga $\mathcal{O}$ ini berfungsi sebagai elemen identitas (nol) dalam operasi penjumlahan.

Artinya, untuk setiap titik $P$ pada kurva, berlaku:

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

Selain itu, invers $-P$ dari titik $P = (x, y)$ didefinisikan sebagai titik $(x, -y)$ yang simetris terhadap sumbu x. Oleh karena itu:

$$ P + (-P) = \mathcal{O} $$

berlaku.

4. Operasi Grup pada Kurva Eliptik (Penambahan Titik dan Penggandaan Titik)

Inti dari kriptografi kurva eliptik adalah operasi “Penambahan (Addition)” antara titik-titik pada kurva. Berbeda dengan penambahan bilangan bulat biasa, ini didefinisikan berdasarkan operasi geometris.

4.1. Penambahan Geometris (Metode Garis Singgung dan Tali Busur / Tangent and Chord Method)

Prosedur untuk menambahkan dua titik berbeda $P$ dan $Q$ pada kurva untuk mendapatkan titik baru $R$ ($R = P + Q$) adalah sebagai berikut:

Tarik garis lurus (tali busur) yang melewati titik $P$ dan titik $Q$.
Garis lurus ini pasti akan memotong kurva eliptik di satu titik lain (mari sebut ini $-R$). (※ Berdasarkan teorema geometri aljabar)
Titik $R$ yang dicari adalah hasil pencerminan titik potong $-R$ secara simetris terhadap sumbu x (titik dengan tanda koordinat y dibalik).

graph TD Step1["Tarik garis lurus yang menghubungkan P(x1, y1) dan Q(x2, y2)"] --> Step2["Temukan persimpangan ketiga -R dengan kurva"] Step2 --> Step3["Cerminkan -R pada sumbu x, untuk mendapatkan R(x3, y3)"] Step3 -.-> Result["Ini adalah R = P + Q"]

4.2. Penggandaan Titik (Point Doubling)

Ketika menambahkan titik $P$ dengan titik $P$ yang sama ($P + P = 2P$), kita tidak dapat menarik garis yang melewati dua titik. Dalam kasus ini, kita menarik garis singgung (Tangent) pada kurva di titik $P$.

Tarik garis singgung pada kurva di titik $P$.
Garis singgung ini memotong kurva di satu titik lain yaitu $-R$.
Titik $R = 2P$ yang dicari adalah hasil pencerminan titik potong tersebut secara simetris terhadap sumbu x.

4.3. Rumus Komputasi Aljabar

Operasi geometris diubah ke dalam rumus aljabar sehingga dapat dihitung oleh komputer. Semua operasi dilakukan di atas lapangan berhingga $\mathbb{F}_p$ (modulo $p$).

Misalkan Titik $P = (x_1, y_1)$ dan Titik $Q = (x_2, y_2)$. Dan biarkan titik hasil perhitungannya adalah $R = P + Q = (x_3, y_3)$.

Biarkan kemiringan garis menjadi $\lambda$ (lambda).

【Kasus 1: Ketika $P \neq Q$ (Penambahan Titik)】 Kemiringan $\lambda$ adalah rasio perubahan antara dua titik.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

Menggunakan $\lambda$ ini, $x_3, y_3$ dihitung sebagai berikut.

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

【Kasus 2: Ketika $P = Q$ (Penggandaan Titik)】 Kemiringan $\lambda$ adalah kemiringan garis singgung yang diperoleh melalui diferensiasi. ($y^2 = x^3 + ax + b$ didiferensiasikan secara implisit)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

Oleh karena itu,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

Rumus untuk $x_3, y_3$ memiliki bentuk yang sama dengan penambahan, tetapi karena $x_2 = x_1$, menjadi seperti berikut:

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] Rumus-rumus ini melibatkan pembagian (perhitungan invers modulo) seperti $(x_2 - x_1)^{-1}$ dan $(2y_1)^{-1}$. Karena perhitungan invers modulo memiliki biaya komputasi yang sangat tinggi, dalam implementasi praktis, sistem koordinat proyektif seperti “Sistem Koordinat Jacobian (Jacobian Coordinates)” umumnya digunakan untuk menunda pembagian.

5. Perkalian Skalar dan Masalah Logaritma Diskret Kurva Eliptik (ECDLP)

Dalam kriptografi kurva eliptik, operasi yang paling padat komputasi dan membentuk inti keamanan adalah Perkalian Skalar (Scalar Multiplication).

5.1. Apa itu Perkalian Skalar?

Menambahkan titik $P$ sebanyak $k$ kali disebut perkalian skalar, dan dilambangkan sebagai $kP$.

$$ kP = \underbrace{P + P + \dots + P}_{k \text{ kali}} $$

Di sini, $k$ adalah bilangan bulat yang sangat besar (misalnya bilangan bulat 256-bit).

5.2. Masalah Logaritma Diskret Kurva Eliptik (ECDLP)

Keamanan kriptografi kurva eliptik bergantung pada kesulitan masalah berikut.

Masalah Logaritma Diskret Kurva Eliptik (Elliptic Curve Discrete Logarithm Problem: ECDLP) Diberikan sebuah titik $P$ (base point) yang diketahui, dan sebuah titik hasil $Q$, temukan skalar $k$ sedemikian rupa sehingga memenuhi $Q = kP$.

Menghitung $Q$ dari $k$ dan $P$ (arah maju) adalah mudah (waktu polinomial) menggunakan algoritma yang dijelaskan di bawah ini, tetapi menghitung balik $k$ dari $P$ dan $Q$ (arah mundur) hampir tidak mungkin tanpa pencarian brute-force (fungsi satu arah). Dalam protokol kriptografi, $k$ berkorespondensi dengan “kunci privat” dan $Q$ dengan “kunci publik”.

5.3. Algoritma Double-and-Add

Ketika $k$ adalah angka yang sangat besar (misalnya: $2^{256}$), menjumlahkan $P$ secara naif sebanyak $k$ kali tidak akan selesai bahkan jika umur alam semesta telah habis. Oleh karena itu, metode Double-and-Add (Metode Biner) digunakan untuk melakukan perkalian skalar dengan kecepatan tinggi.

Ini adalah versi kurva eliptik dari “exponentiation by squaring” yang dengan cepat menghitung pangkat bilangan bulat. Skalar $k$ direpresentasikan dalam biner, dan diproses secara berurutan mulai dari bit paling signifikan.

Inisialisasi titik $R$ yang menyimpan hasil dengan $\mathcal{O}$.
Ulangi yang berikut ini dari bit paling signifikan hingga bit paling tidak signifikan dari $k$:
- Gandakan $R$ (Point Doubling: $R = 2R$)
- Jika bit saat ini adalah 1, tambahkan $P$ ke $R$ (Point Addition: $R = R + P$)

Dengan algoritma ini, kompleksitas waktu berkurang secara drastis dari $O(k)$ menjadi $O(\log_2 k)$, dan memungkinkan perhitungan dalam waktu yang realistis (dalam hitungan milidetik).

6. Pertukaran Kunci Elliptic Curve Diffie-Hellman (ECDH)

Di sini, kami akan menjelaskan cara kerja protokol pertukaran kunci ECDH (Elliptic Curve Diffie-Hellman), yang merupakan contoh aplikasi ECC paling representatif. ECDH adalah mekanisme bagi Alice dan Bob untuk dengan aman menghasilkan dan membagikan kunci rahasia bersama (kunci sesi) melalui saluran komunikasi yang rentan penyadapan (ini adalah inti dari TLS handshake).

【Parameter Prasyarat (Parameter Domain)】 Keduanya berbagi terlebih dahulu kurva eliptik $E$, bilangan prima $p$, dan titik basis $G$ yang akan digunakan. (Misalnya NIST P-256 atau secp256k1)

sequenceDiagram participant Alice as "Alice" participant Bob as "Bob" Note over Alice,Bob: "Parameter publik: Kurva E, Titik Basis G, Bilangan Prima p" Alice->>Alice: "Hasilkan Kunci Privat d_A (bilangan bulat acak)" Alice->>Alice: "Hitung Kunci Publik Q_A = d_A * G" Bob->>Bob: "Hasilkan Kunci Privat d_B (bilangan bulat acak)" Bob->>Bob: "Hitung Kunci Publik Q_B = d_B * G" Alice->>Bob: "Kirim Kunci Publik Q_A (plaintext)" Bob->>Alice: "Kirim Kunci Publik Q_B (plaintext)" Alice->>Alice: "Hitung Rahasia Bersama S = d_A * Q_B" Bob->>Bob: "Hitung Rahasia Bersama S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "Hasil perhitungan S dari keduanya benar-benar cocok!"

Penyadap (Eve) dapat mencegat $G$, $Q_A$, dan $Q_B$ yang mengalir di jalur komunikasi, namun karena kesulitan ECDLP, tidak mungkin menemukan kunci privat $d_A$ milik Alice dari $Q_A = d_A \cdot G$. Selain itu, mengalikan $Q_A$ dan $Q_B$ tidak akan menghasilkan kunci bersama $S$, sehingga penyadap tidak dapat menghitung $S$.

7. Jebakan Implementasi: Serangan Saluran Samping (Side-Channel Attack) dan Penanggulangannya

Bahkan algoritma kriptografi yang sempurna secara teoritis dapat memiliki kerentanan yang muncul dalam proses implementasinya sebagai program. Itulah yang disebut “Serangan Saluran Samping (Side-Channel Attack)”.

7.1. Serangan Waktu (Timing Attack)

Mari kita lihat kembali algoritma Double-and-Add yang telah dijelaskan sebelumnya.

1
2
3
4
5
6
7
8


// Pseudocode dari Double-and-Add yang rentan
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Selalu dieksekusi
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // Hanya dieksekusi ketika bit adalah 1!
 }
}

Implementasi ini memiliki cacat yang fatal. Karena Point Addition dieksekusi saat bit adalah 1, waktu komputasi menjadi sedikit lebih lama daripada saat bit adalah 0. Selain itu, prediski percabangan prosesor dan perilaku memori cache juga berubah. Dengan mengamati perbedaan kecil dalam waktu komputasi (atau konsumsi daya) ribuan kali secara statistik, penyerang dapat sepenuhnya memulihkan rangkaian bit kunci privat $k$ bit demi bit. Inilah yang disebut serangan waktu (timing attack).

7.2. Implementasi Constant-Time: Montgomery Ladder

Untuk mencegah serangan waktu, perlu mengadopsi algoritma yang memiliki urutan instruksi yang dieksekusi dan waktu komputasi yang selalu konstan (Constant-Time), terlepas dari nilai bit kunci privat.

Contoh utamanya adalah Montgomery Ladder.

graph TD Start["Inisialisasi: R0 = O, R1 = P"] --> LoopStart["Untuk setiap bit i (dari bit paling signifikan)"] LoopStart --> Cond{"Berapa nilai k_i?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["Pindah ke bit selanjutnya"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Semua bit selesai"| End["Akhir: R0 adalah hasilnya (kP)"]

Keindahan dari Montgomery Ladder adalah, terlepas dari bit yang bernilai 0 atau 1, “selalu 1 kali Point Addition dan 1 kali Point Doubling” yang dieksekusi. Hal ini sepenuhnya menghilangkan ketergantungan data dari waktu komputasi.

Namun, jika percabangan (if (k_i == 0)) itu sendiri ada, masih ada risiko bahwa waktu eksekusi berfluktuasi karena optimasi compiler dan prediksi percabangan CPU. Oleh karena itu, dalam implementasi Constant-Time yang sebenarnya, percabangan kondisional (pernyataan if) dihilangkan, dan pertukaran bersyarat (Conditional Swap) menggunakan operasi bit digunakan.

8. Implementasi Kriptografi Kurva Eliptik dalam C++

Mulai dari sini, kita akan mengubah teori menjadi kode C++. Pustaka kriptografi praktis (seperti OpenSSL dan libsodium) menggunakan optimasi assembly tingkat lanjut dan sistem koordinat Jacobian, tetapi di sini untuk memperdalam pemahaman matematika, kami menunjukkan kerangka dari implementasi Constant-Time yang mudah dipahami menggunakan sistem koordinat afinitas.

Kami asumsikan penggunaan boost::multiprecision::cpp_int untuk perhitungan bilangan bulat raksasa.

8.1. Operasi Modulo dan Invers

Pertama, kita definisikan fungsi bantuan untuk operasi pada lapangan berhingga. Kita akan mengimplementasikan perhitungan invers menggunakan Teorema Kecil Fermat.

 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


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// Sebagai contoh p dan parameter secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Operasi modulo yang mengembalikan sisa positif
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// Perhitungan eksponensial modulo (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// Invers modulo menggunakan Teorema Kecil Fermat
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Asumsikan bahwa m adalah bilangan prima: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Representasi Titik dan Operasi Grup (Penambahan dan Penggandaan)

Kita definisikan struktur Point yang mengelola titik di tak terhingga dengan sebuah flag, beserta implementasi rumus penambahan.

 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


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // Menghasilkan titik di tak terhingga
 Point() : x(0), y(0), isInfinity(true) {}

 // Menghasilkan titik biasa
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Penambahan titik pada kurva eliptik (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = Titik di tak terhingga
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (Kasus P = Q)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (Kasus P != Q)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Implementasi Conditional Swap Constant-Time

Saat menukar isi variabel berdasarkan nilai bit dari kunci privat, penukaran dilakukan hanya dengan operasi bit (masking) tanpa menggunakan pernyataan if. Hal ini membuat alur eksekusi menjadi benar-benar konstan.

[!TIP] Pada implementasi aslinya, kelas integer multipresisi yang dialokasikan secara dinamis seperti cpp_int tidak cocok untuk pemrosesan Constant-Time. Pasalnya, informasi waktu bocor karena fluktuasi alokasi memori dan ukuran array. Di perpustakaan praktis, algoritma direpresentasikan dalam panjang tetap (misal array uint64_t × 4 elemen), dan memproses masking pada level bit. Berikut adalah contoh konseptual.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Konseptual Constant-Time Swap (Asumsikan panjang bilangan bulat tetap)
// Jika bit adalah 1 maka P1 dan P2 akan ditukar, dan jika 0 maka tidak ditukar
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit adalah 0 atau 1. Masker bit=1 adalah semua bit 1(0xFF..), bit 0 adalah semua bit 0.
 // (Di sini untuk penjelasan, mari kita asumsikan setiap kata dari kelas BigInt panjang tetap sebagai w)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // Koordinat y dan flag isInfinity juga diproses dengan cara yang sama
 }
 */

 // ※ Swap constant-time yang sempurna dengan boost::multiprecision sulit dilakukan,
 // Di sini kita batasi pada simulasi dengan percabangan demi memahami logikanya.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Perkalian Skalar dengan Montgomery Ladder

Menggabungkan pointAdd dan cswap di atas, kita mengimplementasikan perkalian skalar yang aman.

 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


// Perkalian skalar k * P (Metode Montgomery Ladder)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Titik di tak terhingga
 Point R1 = P;

 // Dapatkan panjang bit k (untuk secp256k1 adalah 256 bit)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Dapatkan nilai bit ke-i (0 atau 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Jika bit == 1, tukar R0 dan R1
 cswap(R0, R1, bit);

 // Selalu eksekusi operasi yang sama (Point Addition dan Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Jika bit == 1, tukar lagi untuk mengembalikan keadaan seperti semula
 cswap(R0, R1, bit);
 }

 return R0;
}

Dengan logika implementasi ini, terlepas dari apakah masing-masing bit skalar $k$ adalah 0 atau 1, operasi yang dieksekusi dalam setiap iterasi perulangan (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) akan memiliki alur yang persis sama, dengan kuat mencegah kebocoran informasi rahasia melalui waktu atau perbedaan dalam pola akses cache.

9. Kesimpulan

Kriptografi kurva eliptik (ECC) mungkin tampak aneh pada pandangan pertama dengan bertanya-tanya, “Mengapa operasi geometris seperti menggambar garis lurus dan memantulkan titik persimpangan dapat menjadi kriptografi?”. Namun, dengan memetakannya ke dunia diskrit dari lapangan berhingga, ini adalah produk perpaduan yang ajaib antara matematika dan kriptografi, yang memungkinkan kita membangun fungsi satu arah yang mengesankan (masalah logaritma diskret).

Dalam artikel ini, kami menjelaskan poin-poin penting berikut:

Keunggulan terhadap RSA: Memberikan keamanan kuat dengan panjang kunci yang jauh lebih pendek, sangat cocok untuk era perangkat seluler dan IoT modern.
Dasar-dasar Teori Grup dan Lapangan Berhingga: Struktur matematika yang mendasari ECC.
Rumus Penambahan dan Penggandaan: Metode untuk mengimplementasikan operasi grup aljabar menggunakan persamaan Weierstrass.
Ancaman Serangan Saluran Samping (Side-Channel Attack): Bagaimana percabangan kondisional yang bergantung pada bit kunci privat menghasilkan kerentanan yang fatal.
Implementasi Constant-Time: Teknik pengkodean C++ yang menggunakan Montgomery Ladder dan Conditional Swap untuk menyeragamkan perilaku tingkat perangkat keras dan mencegah serangan.

Membuat perpustakaan kriptografi Anda sendiri yang sebenarnya berjalan di lingkungan produksi sangat tidak disarankan (“Don’t roll your own crypto”) karena risiko keamanannya sangat tinggi. Namun, pemahaman mendalam tentang algoritma dan latar belakang matematika yang beroperasi di dalamnya harus menjadi senjata yang sangat berharga bagi insinyur yang merancang dan mengoperasikan sistem yang lebih aman dan berkinerja tinggi.

Pada artikel berikutnya, kami ingin menggali lebih dalam tentang mekanisme ECDSA (Elliptic Curve Digital Signature Algorithm), yaitu algoritma tanda tangan digital menggunakan kurva eliptik ini, serta Tanda Tangan Schnorr yang diadopsi pada Bitcoin.