√ Kerentanan Reused R Pada Transaksi Bitcoin yang Menyebabkan Kehilangan Saldo

Kerentanan Reused R Pada Transaksi Bitcoin yang Menyebabkan Kehilangan Saldo

terimakasih.eu.org

November 21, 2025

Apa itu kerentanan Reused R? Pada ECDSA (algoritma tanda tangan Bitcoin), setiap kali kita menandatangani transaksi, kita harus menghasilkan sebuah angka acak yang disebut nonce atau k, namun dalam banyak literatur sering disebut r (karena r = (k·G).x mod n).

Nonce k/r harus RANDOM, UNIK, dan TIDAK BOLEH DIULANG.

Jika nonce r/k digunakan lebih dari sekali, maka private key langsung bocor atau dapat dihitung dengan sangat mudah dari dua tanda tangan berbeda.

Ini disebut vulnerability reused r atau nonce reuse vulnerability.

🔧 Bagaimana cara kerjanya?

Pada ECDSA, tanda tangan Bitcoin menghasilkan dua angka: r dan s.

Rumus tanda tangan ECDSA:

s = k⁻¹ (z + r·d) mod n

di mana:

d = private key
k = nonce acak (harus unik)
z = hash pesan (hash transaksi)
r = koordinat x dari k·G

Jika seseorang tidak sengaja memakai nonce yang sama k (berarti r juga sama), maka kita mendapatkan:

s1 = k⁻¹ (z1 + r·d) mod n
s2 = k⁻¹ (z2 + r·d) mod n

Karena k sama → r sama, maka tinggal lakukan operasi matematika sederhana:

1️⃣ Ambil selisih dua persamaan:

s1 - s2 = k⁻¹ (z1 - z2)

2️⃣ Dari sini, kita bisa dapatkan k:

k = (z1 - z2) / (s1 - s2) mod n

3️⃣ Setelah dapat k, private key d langsung ditemukan:

d = (s1·k - z1) / r mod n

Sangat mudah bagi siapapun yang melihat signature di Blockchain.

⚠️ Mengapa ini sangat berbahaya?

Karena jika sekali saja wallet (atau library, atau implementasi) memakai nonce yang sama dalam dua transaksi berbeda, maka:

🔥 Private key langsung bocor 100%

Tidak butuh bruteforce
Tidak butuh kekuatan komputasi besar
Cukup melihat dua tanda tangan ECDSA
Dalam hitungan milidetik private key bisa dihitung

🔥 Semua BTC dalam wallet langsung bisa dicuri

Penyerang cukup:

Melihat transaksi di blockchain,
Menemukan dua tanda tangan dengan r yang sama,
Menghitung private key,
Menghabiskan saldo.

Sudah banyak kasus nyata hack r reuse di dunia nyata (termasuk Android 2013, PlayStation 3, dan beberapa library yang gagal membuat nonce acak).

🧪 Contoh nyata (ilustrasi sederhana)

Misal sebuah wallet menandatangani 2 transaksi seperti ini:

Signature 1: r = 7731..., s = 8328..., z = 7fa3...
Signature 2: r = 7731..., s = 6551..., z = bb91...

Karena r sama → berarti k sama.

Maka private key dapat dihitung hanya dengan beberapa operasi matematika biasa.

💡 Mengapa r bisa terulang?

Beberapa penyebab umum:

1️⃣ Random number generator (RNG) buruk

Wallet men-generate k dengan random generator yang lemah.

2️⃣ Bug pada implementasi ECC

Ada bug pada library kriptografi yang membuat nonce terulang.

3️⃣ Perangkat low entropy

Misalnya:

Android lama
IoT
CPU tanpa hardware RNG

4️⃣ Deterministic nonces salah implementasi

Wallet modern memakai RFC6979 untuk membuat nonce deterministik.
Jika implementasi salah → bisa bocor.

🛡️ Bagaimana pencegahannya?

✔ Gunakan RFC6979 deterministic nonce
✔ Pastikan RNG aman (misal /dev/urandom)
✔ Jangan membuat implementasi ECDSA sendiri
✔ Gunakan library kriptografi yang teruji

Semua wallet Bitcoin modern sudah mengikuti aturan ini.

🧠 Ringkasannya

Reused r = menggunakan nonce ECDSA (k/r) yang sama dua kali.

Akibatnya:

attacker dapat menghitung k
lalu menghitung private key
lalu menghabiskan semua BTC Anda

Ini adalah salah satu kerentanan paling mematikan dalam kriptografi ECDSA.

Penyebab

Penyebab utama reused r / reused nonce (k) selalu berasal dari satu akar masalah besar:

⚠️ NONCE k TIDAK DIBUAT SECARA ACAK DAN UNIK

Dan ada beberapa penyebab teknis utama yang secara nyata terjadi di dunia:

🔥 1. Random Number Generator (RNG) Jelek / Lemah (penyebab terbesar)

Inilah penyebab paling utama dan paling sering terjadi.

Jika wallet atau library membuat nonce tidak benar-benar acak, misalnya:

RNG menghasilkan angka yang sama,
RNG hanya memakai jam sistem,
RNG tidak dapat cukup entropy (randomness yang sedikit),
RNG didesain buruk,

maka nonce k bisa terulang → r terulang → private key bocor.

Contoh kasus nyata:

Android SecureRandom bug (2013)
Banyak wallet Android saat itu menggunakan RNG yang broken sehingga menghasilkan nonce yang sama → ribuan BTC dicuri.

🔥 2. Perangkat kekurangan Entropy (Randomness Rendah)

Terjadi pada:

handphone low-end sangat lama
IoT devices
embedded devices
environment virtual (container / VM) yang cold-boot

Jika entropy rendah, maka:

nonce yang dihasilkan bisa sama,
atau hampir sama (predictable).

➡️ Ini penyebab umum bagi wallet yang berjalan di perangkat kecil.

🔥 3. Implementasi ECDSA buatan sendiri yang salah

Banyak programmer membuat implementasi ECDSA sendiri, tetapi:

salah merandom nonce,
k dibuat dari random() atau Math.random() (fatal),
atau mereka mengulang k secara tidak sengaja.

Wallet “rumahan” atau library kecil sangat rentan karena mereka tidak mengikuti standar.

🔥 4. Bug dalam penggunaan deterministic nonce (RFC6979)

Wallet modern menggunakan RFC6979, yaitu nonce deterministik yang aman dan tidak perlu randomness.

Tapi jika implementasinya salah:

salah mem-parsing hash transaksi,
salah dalam fungsi HMAC,
salah dalam modul n,

nonce bisa terulang dan private key bocor.

➡️ Beberapa library kecil pernah terkena masalah ini.

🔥 5. Server Side Signing (HSM / API) yang reuse nonce

Jika pengguna memakai server untuk sign transaksi, contoh:

web wallet,
exchange wallet,
hardware security module (HSM),

dan server/cache menyimpan nonce sebelumnya atau salah meng-handle sign request, maka nonce bisa dipakai ulang.

🔥 6. Perangkat lunak mengulang nonce karena crash/restore state

Jika suatu wallet menyimpan status RNG atau state k, lalu crash, dan setelah reboot memakai nilai RNG lama, maka nonce yang sama bisa muncul.

Banyak kasus terjadi di embedded devices atau hardware wallet versi lama.

🔥 7. Menggunakan library crypto yang “bermutasi” setelah update

Beberapa update library (misal python-ecdsa, JS crypto libs) pernah memiliki bug sehingga nonce yang dihasilkan:

sama,
atau predictable.

Itu terjadi saat developer tidak sadar bahwa perubahan kecil bisa merusak k.

📌 Jadi, apa penyebab UTAMA yang paling sering?

➜ RNG low-quality / entropy rendah adalah penyebab nomor 1.

➜ Disusul implementasi ECDSA buatan sendiri yang salah.

Kedua hal ini menyumbang >90% kasus reuse r di dunia nyata.

Estimasi Kerugian

Berikut estimasi kerugian Bitcoin yang pernah terjadi akibat reuse nonce (reused r/k) dari berbagai kasus nyata. Semua nilai ini berasal dari insiden dengan bukti publik dan penelitian keamanan.

🧨 1. Android SecureRandom Bug (2013)

Kasus terbesar dan paling terkenal.
Wallet Android memakai RNG yang rusak, menyebabkan k terulang → private key bocor.

Estimasi kerugian:
👉 sekitar 600–1.500 BTC hilang
(tergantung sumber analisis peneliti waktu itu)

Nilai hari ini:
600 BTC = ± $40 juta
1.500 BTC = ± $100 juta

🧨 2. PlayStation 3 ECDSA Hack (contoh non-BTC tetapi ECDSA)

Kasus ini bukan Bitcoin, tetapi kasus ECDSA reuse nonce paling terkenal.
Dari sini, seluruh private key Sony bocor hanya karena reused k.

Kerugian finansial tidak dihitung dalam BTC, tapi ini membuktikan reuse k = langsung bocor.

🧨 3. Library Bitcoin Lama (Python ECDSA & JS Crypto)

Sebelum RFC6979 menjadi standar, beberapa library:

python-ecdsa,
bitcoinjs-lib versi lama,
beberapa library Java & C,

pernah menghasilkan nonce tidak acak atau predictable.

Estimasi kerugian:
👉 5–50 BTC
(malware + opportunistic attacker mencuri dari pengguna kecil)

Nilai hari ini:
5 BTC = ± $350 ribu
50 BTC = ± $3,5 juta

🧨 4. Web Wallet yang Menggunakan RNG Buruk (2014–2016)

Beberapa online wallet lama (terutama yang gratisan atau tidak open-source) pernah menggunakan RNG JavaScript yang lemah.

Estimasi kerugian:
👉 50–200 BTC dicuri
(banyak insiden kecil-kecilan)

🧨 5. Kasus Penelitian 2020–2022: Reused Nonce in the Wild

Peneliti kriptografi menemukan ratusan tanda tangan Bitcoin lama (2012–2014) yang memakai reused r.

Sebagian besar address sudah kosong atau sudah dicuri.

Estimasi kerugian:
👉 20–80 BTC
(hasil analisis jurnal akademik)

📊 Total Estimasi Kerugian Akibat Reused Nonce (Semua Tahun)

Jika semua dijumlahkan:

Sumber	Estimasi BTC
Android bug 2013	600–1500 BTC
Library crypto lemah	5–50 BTC
Web wallet RNG buruk	50–200 BTC
Penemuan penelitian	20–80 BTC

Total estimasi:
👉 675 – 1.830 BTC hilang akibat reused r
👉 Dalam nilai hari ini:
$45 juta – $120+ juta USD

🧨 Kenapa angka ini bisa lebih besar dari yang terlihat?

Karena:

Banyak korban tidak tahu bahwa pencuriannya berasal dari reused r.
Banyak wallet lama (2011–2013) tidak tercatat.
Beberapa penyerang menyebarkan banyak transaksi kecil untuk menutupi metode hacking.
Tidak ada catatan resmi global.

Sehingga angka sebenarnya bisa 2–3x lebih besar dari estimasi.