Metode eksak dengan pemanfaatan batas bawah dan batas atas Φ(n) (teori Fang-

BAB II TINJAUAN PUSTAKA

2.4 Metode eksak dengan pemanfaatan batas bawah dan batas atas Φ(n) (teori Fang-

Kloster (2010) menyebutkan bahwa bila n = pq dan Φ(n) = (p − 1)(q − 1), maka p dan q adalah akar dari persamaan kuadrat x² − (n − Φ(n) + 1)x + n = 0. Karena di dalam RSA nilai n diketahui, maka langkah selanjutnya adalah mengetahui bagaimana hubungan antara n dan Φ(n).

Fang dan Liu (2017) menemukan bahwa batas bawah (lower bound) dan batas atas (upper bound) dari Φ(n) adalah sebagai berikut.

Batas ini selanjutnya akan disebut sebagai batas Fang-Liu. Pada RSA 200, maka ε = 0,99999.

Tabel 2.1 Persamaan digit bilangan n dan Φ(n) pada RSA-200 (Fang dan Liu, 2017)

Pada Tabel 2.1, terlihat bahwa digit-digit pertama bilangan n dan Φ(n) mempunyai persamaan hampir 50%. Dengan demikian, apabila nilai n telah diketahui dan nilai Φ(n) hendak dicari, maka proses pencarian dapat dimulai dari separuh digit n pertama saja, tidak lagi dari awal. Hal ini tentu saja akan mempercepat pencarian Φ(n), dan karenanya, menjadi sangat penting. Diharapkan, metode metaheuristik juga dapat membantu mempercepat pencarian digit-digit terakhir bilangan Φ(n).

BAB III

METODE PENELITIAN

3.1. Pendahuluan

Tingkat keamanan algoritma RSA tergantung kepada sulitnya memfaktorkan modulusnya (kunci publiknya), yaitu n, menjadi kunci-kunci privatnya, yaitu p dan q. Nilai n yang kecil akan menyebabkan algoritma RSA dengan mudah terkriptanalisis. Semakin besar nilai n, akan semakin sulit untuk memfaktorkan kunci publik RSA.

Sebagai contoh, bila n = 35, maka tanpa bantuan komputer pun, seseorang dapat memfaktorkan 35 = 7 × 5. Sementara itu, bila n = 221, maka tidak terlalu mudah bagi manusia untuk memfaktorkannya menjadi 221 = 13 × 19, namun mudah sekali bagi komputer untuk menyelesaikannya dengan teknik brute force (mencoba semua kemungkinan dalam ruang solusi).

Bila diambil nilai yang jauh lebih panjang, misalnya n = 12698378279147986655129 atau 23 digit, sudah tidak mungkin lagi bagi manusia untuk memfaktorkannya, dan komputer pun akan membutuhkan waktu yang sangat lama untuk memfaktorkan 12698378279147986655129 = 67326963541 × 188607618869 dengan teknik brute force.

Sementara itu, nilai n yang disarankan untuk RSA adalah 309 digit, yang berarti jauh melebihi 23 digit. Dengan demikian, memfaktorkan n menjadi tidak layak secara komputasi (computationally infeasible). Oleh karena itu, teknik brute force dipandang tidak layak untuk memfaktorisasi modulus RSA.

3.2. Data yang Digunakan

Di dalam penelitian ini, digunakan nilai n dari yang sekecil-kecilnya, yakni 2 digit sampai dengan sebesar-besarnya (tidak dibatasi). Pada tahap penelitian selanjutnya, nilai e dan Φ(n) berbeda-beda juga akan diteliti dampaknya terhadap faktorisasi n.

3.3. Metode yang Diusulkan

Pada awal penelitian, nilai n dengan jumlah digit berbeda-beda akan difaktorisasi dengan 5 (lima) metode metaheuristik yaitu random search, iterated local search,, random-restart hill

climbing, steepest ascent hill climbing, dan tabu search. Kemudian, akan dipilih metode metaheuristik mana yang menghasilkan waktu faktorisasi yang paling cepat.

Selanjutnya, nilai-nilai n yang telah digunakan dengan metode metaheuristik tersebut akan diujicobakan kembali untuk difaktorisasi dengan 5 (lima) metode eksak, yaitu Fermat difference of squares, Euler factorization, Brent factorization, Pollard, dan Pollard rho.

Kemudian, akan dipilih metode faktorisasi mana yang menghasilkan waktu faktorisasi yang paling cepat.

Selanjutnya, akan diteliti apakah ada hubungan-hubungan khusus antara n dengan e dan Φ(n). Sebelumnya, telah diketahui hubungan-hubungan umum antara parameter-parameter tersebut, yaitu:

1. n = pq

2. Φ(n) = (p – 1)(q – 1) 3. 1 < e < Φ(n)

4. gcd(Φ(n), e) = 1

Dengan mengetahui hubungan-hubungan yang khusus antara n dengan e dan Φ(n), maka akan dikembangkan sebuah algoritma baru yang merupakan campuran antara metode metaheuristik tercepat dan metode eksak tercepat. Diharapkan, algoritma baru ini akan dapat memfaktorisasi modulus RSA secara lebih cepat dibandingkan dengan metode-metode metaheuristik dan eksak sebelumnya.

3.4 Beberapa Hasil Penelitian Awal

Beberapa penelitian awal telah dilakukan, dan hasilnya telah dipublikasi pada:

1. Data Science – Journal of Computing and Applied Informatics Vol. 01, No. 2, Tahun 2018, hal 48-56, dengan judul “Using random search and brute force algorithm in factoring the RSA modulus”.

2. Data Science – Journal of Computing and Applied Informatics Vol. 01, No. 1, Tahun 2017, hal 30-38, dengan judul “On factoring the RSA modulus using tabu search”

3. Journal of Physics: Conference Series Vol. 943, Tahun 2017, hal 012057, dengan judul

“On factoring RSA modulus using random-restart hill climbing algorithm and Pollard’s rho algorithm” yang sebelumnya telah diseminarkan di AD INTERCOMME

International Conference on Mathematics and Mathematics Education, 13-14 Oktober 2017.

Dari ketiga publikasi tersebut, untuk sementara dapat disimpulkan bahwa tiga metode faktorisasi eksak yang diuji (brute force, Pollard, dan Pollard rho) masih lebih unggul dari segi waktu komputasi daripada metode metaheuristik yang diuji (random search, random restart hill climbing, dan tabu search).

Keunggulan waktu metode faktorisasi eksak ini sangat signifikan, sehingga hampir-hampir dapat disimpulkan bahwa metode faktorisasi eksak jauh lebih layak digunakan untuk memfaktorisasi modulus RSA dibandingkan metode metaheuristik. Kendati demikian, masih ada tiga metode metaheuristik dan empat metode faktorisasi eksak lain yang harus diteliti untuk mendapatkan kesimpulan yang tetap.

Selanjutnya, masih dimungkinkan bahwa metode metaheuristik dapat membantu mengubah metode nonfaktorisasi eksak menjadi metode faktorisasi campuran, yaitu dengan meneliti hubungan-hubungan khusus antara n dengan e dan Φ(n) dan melihat apakah metode metaheuristik dapat mempercepat untuk mendapatkan Φ(n) bila diketahui nilai n. Bila Φ(n) bisa dengan cepat diketahui dengan bantuan metode metaheuristik, maka p dan q dapat dicari semudah mencari akar dari persamaan kuadrat x² − (n − Φ(n) + 1)x + n = 0.

3.5 Algoritma Baru untuk Memfaktorkan Modulus RSA

Seperti dikemukakan pada Bab 2, hubungan antara n dengan Φ(n) berada dalam batas Fang-Liu sebagai berikut.

Dengan demikian, bila nilai n diketahui, maka nilai Φ(n) cukup dicari secara iteratif dalam batas Fang-Liu tersebut.

Selanjutnya, telah diketahui bahwa n = pq di mana p dan q adalah bilangan prima x1 dan x2 yang merupakan akar dari persamaan kuadrat x² − (n − Φ(n) + 1)x + n = 0. Maka, untuk mencari nilai p dan q, cukuplah melakukan iterasi nilai Φ(n) dalam batas Fang-Liu di atas, yang menyebabkan x1 dan x2 menjadi bilangan prima.

Berdasarkan pendekatan-pendekatan di atas, sebuah algoritma baru untuk

memfaktorkan modulus RSA dikembangkan. Algoritma tersebut dipaparkan dalam bentuk pseudocode, sebagai berikut.

input n

let epsilon = 0.99999

let lowerbound = int((3 + epsilon) * floor((n - 2 * ceil(sqrt(n)) + 1) / 4))

if (lowerbound mod 2 = 1) {

lowerbound = lowerbound – 1

} // make sure that the starting point is even since totient must be even

let upperbound = int(4 * floor((n - 2 * ceil(sqrt(n)) + 1) / 4))

if (upperbound mod 2 = 1) {

upperbound = upperbound + 1

} // make sure that the ending point is even since totient must be even

let a = 1 let c = n

// a and c are the constants of the quadratic equation ax^2 + bx + c = 0

let totient = upperbound let iterations = 1

let x1 = 0 let x2 = 0

while (totient ≠ lowerbound) {

let b = -(n - totient + 1)

// b is the constant of the quadratic equation ax^2 + bx + c = 0 let D = b ^ 2 - 4 * a * c

// D is the discriminant of the quadratic equation ax^2 + bx + c = 0

if (D < 0) {

// if the discriminant is negative, no roots can be derived let totient = totient - 4

let iterations = iterations + 1 continue while

}

let x1 = (-b + sqrt(D)) / (2 * a) let x2 = (-b - sqrt(D)) / (2 * a) if (x1 and x2 are integers) {

output x1, x2 // p and q are found exit while

}

let totient = totient - 4

let iterations = iterations + 1 }

Karena algoritma baru ini hanya memiliki satu buah loop yang independen terhadap fungsi lain, maka dapat diprediksi bahwa kompleksitas algoritma ini adalah θ(n), di mana n adalah modulus RSA.

BAB IV

HASIL DAN DISKUSI

Berikut ini akan dipaparkan hasil eksperimen pemfaktoran modulus RSA dengan lima algoritma metaheuristik, lima algoritma eksak, dan algoritma baru tersebut. Eksperimen dilakukan pada komputer 64-bit dengan spesifikasi Chip A12X Bionic dengan Neural Engine dan koprosesor M12, dengan sistem operasi iOS 12. Sementara itu, bahasa pemrograman yang digunakan adalah bahasa Python 2 dengan integrated development environment Pythonista versi 2.1.1 (2110008).

Eksperimen dilakukan dengan memfaktorisasi nilai n yang kecil hingga besar dan mencatat real running time masing-masing algoritma dalam seconds. Pertama-tama, akan diuji lima algoritma metaheuristik, yaitu random search, iterated local search, random-restart hill climbing, steepest ascent hill climbing, dan tabu search untuk mengetahui algoritma tercepat di kelas metaheuristik tersebut. Kemudian, akan diuji lima metode eksak, yaitu Fermat difference of squares, Euler factorization, Brent factorization, Pollard, dan Pollard rho untuk mengetahui algoritma tercepat di kelas eksak tersebut. Dari algoritma tercepat kelas metaheuristik dan algoritma tercepat kelas eksak tersebut akan dipilih pula yang mana yang lebih cepat di antara keduanya. Selanjutnya, algoritma tercepat ini akan menjadi benchmark bagi algoritma baru.

4.1. Hasil Algoritma Random Search

Berikut ini disajikan output lengkap algoritma random search untuk pemfaktoran n = 35.

Factoring n = 35

initialization [p, q] = [17, 13]

delta best = 186.0

exporation # 1 [p, q] = [13, 23]

delta S = 264.0 delta best = 186.0

exporation # 2

running time 0.00182008743286 secs

Gambar 4.1 Pemfaktoran n = 35 dengan algoritma random restart

Pada Gambar 4.1, terlihat bahwa untuk memfaktorkan n = 35 = 5 * 7, dibutuhkan 8 eksplorasi.

Sedangkan untuk kasus n = 143, outputnya adalah sebagai berikut. (Output dirampingkan untuk menghemat halaman)

n = 143

initialization [p, q] = [67, 61]

delta best = 3944.0 exporation # 1 [p, q] = [103, 59]

delta S = 5934.0 delta best = 3944.0

exporation # 2 [p, q] = [103, 83]

delta S = 8406.0 delta best = 3944.0

exporation # 3 [p, q] = [41, 139]

delta S = 5556.0 delta best = 3944.0

exporation # 4 [p, q] = [23, 13]

delta S = 156.0

delta best = 3944.0

exporation # 5 [p, q] = [109, 73]

delta S = 7814.0 delta best = 156.0

. . .

exporation # 93 [p, q] = [127, 61]

delta S = 7604.0 delta best = 12.0

exporation # 94 [p, q] = [83, 19]

delta S = 1434.0 delta best = 12.0

exporation # 95 [p, q] = [11, 13]

delta S = 0.0 delta best = 12.0

success [11, 13]

running time 0.529484987259 secs

Gambar 4.2 Pemfaktoran n = 143 dengan algoritma random search

Pada Gambar 4.2, terlihat bahwa untuk memfaktorkan n = 143 = 11 * 13, dibutuhkan

95 eksplorasi. Kendati waktu pemfaktoran yang dibutuhkan masih di bawah 1 detik, hal ini menjadi indikasi bahwa untuk pemfaktoran n dengan jumlah digit yang sedikit lebih besar, akan dibutuhkan sangat banyak iterasi.

Untuk membuktikan prediksi di atas, maka dicoba memfaktorkan n = 437, dengan hasil sebagai berikut.

Factoring n = 437

initialization [p, q] = [193, 191]

delta best = 36426.0

exporation # 1 [p, q] = [19, 17]

delta S = 114.0 delta best = 36426.0

exporation # 2

time's up

Gambar 4.3 Pemfaktoran n = 437 dengan algoritma random search

Pada Gambar 4.3, terlihat bahwa kendati limit waktu 10 detik telah terlampaui dan sudah dilakukan 1461 eksplorasi, algoritma random search gagal mendapatkan hasil. Dengan demikian, dapat disimpulkan bahwa algoritma random search sama sekali tidak cocok untuk memfaktorkan modulus RSA.

4.2. Hasil Algoritma Iterated Local Search

Berikut ini disajikan output lengkap algoritma iterated local search untuk pemfaktoran n = 2173.

Factoring n = 2173

T = [0.0682857682243335, 0.061252044954216, 0.07873027964653073, 0.09904621287121335, 0.0635033855694833, 0.008403895832084474, 0.01151146489964322, 0.016737022935004443, 0.05575651789168726, 0.08553852055623169]

walk = [61, 37]

walk = [139, 13]

walk = [89, 29]

walk = [107, 19]

walk = [37, 59]

walk = [41, 53]

success [41, 53]

running time 0.00274395942688 secs

Gambar 4.4 Pemfaktoran n = 2173 dengan algoritma iterated local search

Pada Gambar 4.4, terlihat bahwa untuk memfaktorkan n = 2173 = 41 * 53 dibutuhkan waktu 0.00274395942688 detik, 6 langkah kecil (walk), dan hanya satu kali eksplorasi (lompatan besar).

Sebagai perbandingan dicoba untuk memfaktorkan n = 3953. Hasil yang didapat adalah sebagai berikut.

Factoring n = 3953

T = [0.02510115290220809, 0.0456744846948177, 0.09164139892224568, 0.002687020266023288, 0.01695121714284732, 0.09933434002878339, 0.04156156408936591, 0.005437964527489992, 0.06622031992346361, 0.06784426418288096]

walk = [89, 43]

walk = [101, 43]

walk = [61, 67]

walk = [157, 23]

walk = [97, 37]

walk = [89, 43]

walk = [59, 67]

success [59, 67]

running time 0.00661706924438 secs

Gambar 4.5 Pemfaktoran n = 3953 dengan algoritma iterated local search

Pada Gambar 4.5, terlihat bahwa untuk memfaktorkan n = 3953 = 59 * 67 dibutuhkan waktu 0.00661706924438 detik, 7 langkah kecil (walk), dan hanya satu kali eksplorasi (lompatan besar).

Factoring n = 286921

T = [0.05129616906294528, 0.06438520236111282, 0.030875124900050066,

0.054421544443041786, 0.021043831902229894, 0.04900866577194679, 0.06444236490290614, 0.019006295101937843, 0.05081710678755599, 0.05549362079525512]

walk = [607, 467]

walk = [661, 431]

walk = [701, 409]

. . .

walk = [409, 701]

walk = [479, 599]

success [479, 599]

running time 0.0631878376007 secs

Gambar 4.6 Pemfaktoran n = 286921 dengan algoritma iterated local search

Pada Gambar 4.6, terlihat bahwa untuk memfaktorkan n = 286921 = 479 * 599 dibutuhkan waktu 0.0631878376007 detik, 61 langkah kecil (walk), dan hanya satu kali eksplorasi (lompatan besar).

Di sini dapat disimpulkan bahwa banyaknya eksplorasi tidaklah terlalu menentukan kecepatan algoritma iterated local search untuk memfaktorkan modulus. Yang lebih menentukan adalah banyaknya langkah kecil (walk).

Dalam eksperimen berikutnya, algoritma iterated local search ternyata gagal

menemukan faktor dari n = 1017937 bila diberikan waktu kurang dari 10 detik. Dengan demikian, dapat disimpulkan bahwa algoritma iterated local search hanya cocok untuk memfaktorkan modulus RSA yang kecil saja.

4.3. Hasil Algoritma Random Restart Hill Climbing

Berikut ini disajikan output lengkap algoritma random restart hill climbing untuk pemfaktoran n = 286921.

Factoring n = 286921

n = 286921

Finding p and q, starting from 163 and above

R = [599, 463]

R = [389, 619]

R = [331, 971]

. . .

R = [223, 1279]

R = [271, 1217]

R = [271, 1213]

R = [571, 397]

R = [269, 1051]

R = [523, 541]

R = [503, 419]

R = [347, 811]

R = [419, 661]

R = [479, 599]

best = [479, 599]

success [479, 599]

running time 0.0775530338287 secs

Gambar 4.7 Pemfaktoran n = 286921dengan algoritma random restart hill climbing

Pada Gambar 4.7, terlihat bahwa untuk memfaktorkan n = 286921 = 479 * 599 dibutuhkan waktu 0.0775530338287 detik, 60-an kali eksplorasi (lompatan besar), dan 2700-an kali walk (l2700-angkah kecil).

Berikutnya, dicoba memfaktorkan nilai n yang lebih besar, yaitu n = 536113, dengan hasil sebagai berikut.

Factoring n = 536113

n = 536113

Finding p and q, starting from 277 and above

R = [373, 1483]

. . .

R = [463, 983]

R = [367, 1367]

R = [487, 1021]

R = [461, 1153]

R = [523, 751]

R = [439, 1129]

R = [653, 587]

R = [293, 1619]

R = [653, 821]

best = [653, 821]

success [653, 821]

running time 0.0153210163116 secs

Gambar 4.8 Pemfaktoran n = 536113 dengan algoritma random restart hill climbing

Pada Gambar 4.8, terlihat bahwa untuk memfaktorkan n = 536113 = 653 * 821 dibutuhkan waktu 0.0153210163116 detik, 60 kali eksplorasi (lompatan besar), dan 2000-an kali walk (langkah kecil). Walaupun n yang difaktorkan lebih besar, namun waktu, eksplorasi, dan walk yang dibutuhkan lebih kecil. Hal ini adalah karena algoritma ini sangat tergantung kepada starting point yang diambil: apa bila semakin dekat dengan solusi, maka semakin baik. Kebetulan, starting point yang diambil, yaitu 277, sudah dekat dengan hasil [653, 821].

Dengan demikian, dapat disimpulkan bahwa algoritma random restart hill climbing dapat digunakan untuk memfaktorkan RSA dengan syarat bila starting point yang diambil, cukup dekat dengan solusi. Namun, algoritma ini dapat berjalan dengan lamban bila modulus RSA yang hendak difaktorkan terlalu besar.

4.4. Hasil Algoritma Steepest Ascent Hill Climbing with Replacement

Berikut ini disajikan output algoritma steepest ascent hill climbing with replacement untuk pemfaktoran n = 64777.

Factoring n = 64777 R = [577, 109]

W = [1409, 37]

running time 0.761335134506 secs

Gambar 4.9 Pemfaktoran n = 64777 dengan algoritma steepest ascent hill climbing with replacement

Pada Gambar 4.9, terlihat bahwa untuk memfaktorkan n = 64777 = 307 * 211 dibutuhkan waktu 0.761335134506 detik, 61 kali eksplorasi (lompatan besar), dan 500-an kali walk (langkah kecil).

Kemudian, dicoba memfaktorkan nilai modulus yang jauh lebih besar, yaitu n = 5601209. Hasilnya adalah sebagai berikut.

Factoring n = 5601209 R = [1303, 4297]

[1303, 4297]

W = [2593, 2153]

W = [2083, 2699]

W = [3793, 1471]

W = [2539, 2203]

W = [2339, 2399]

W = [3229, 1733]

W = [2707, 2063]

W = [2609, 2141]

W = [3739, 1489]

R = [1879, 2971]

[1879, 2971]

W = [1621, 3463]

W = [2099, 2663]

W = [1997, 2797]

W = [1709, 3271]

W = [2039, 2741]

R = [599, 9343]

[599, 9343]

W = [977, 5743]

W = [1697, 3301]

W = [1087, 5153]

W = [2017, 2777]

W = [727, 7699]

W = [1697, 3299]

W = [1481, 3793]

W = [491, 11411]

W = [1933, 2897]

success [2017, 2777]

running time 0.0306921005249 secs

Gambar 4.10 Pemfaktoran n = 5601209 dengan algoritma steepest ascent hill climbing with replacement

Pada Gambar 4.10, terlihat bahwa untuk memfaktorkan n = 5601209 = 2017* 2777 dibutuhkan waktu 0.0306921005249 detik, 3 kali eksplorasi (lompatan besar), dan 27 kali walk (langkah kecil).

Hasil ini cukup mengejutkan, karena untuk memfaktorkan modulus yang jauh lebih besar, algoritma steepest ascent hill climbing with replacement justru membutuhkan waktu, walk, dan eksplorasi yang lebih sedikit. Namun, sekali lagi, sebagai algoritma yang memanfaatkan fungsi random untuk membangkitkan solusi, algoritma ini juga sangat bergantung kepada pemilihan starting point, semakin dekat dengan solusi, semakin baik (baca: sedikit) pula waktu, walk, dan eksplorasinya.

4.5. Hasil Algoritma Tabu Search

Berikut ini disajikan output algoritma tabu search untuk pemfaktoran n = 143.

Factoring n = 143

W = [23, 11]

W = [29, 11]

W = [17, 19]

W = [31, 11]

W = [11, 19]

W = [31, 7]

W = [29, 7]

W = [23, 5]

W = [17, 13]

W = [29, 13]

W = [23, 11]

W = [23, 5]

W = [19, 17]

W = [11, 13]

success [11, 13]

running time 0.2977039814 secs

Gambar 4.11 Pemfaktoran n = 143 dengan algoritma tabu search

Pada Gambar 4.11, terlihat bahwa untuk memfaktorkan n = 143 = 11* 13 dibutuhkan waktu 0.2977039814 detik, 3 kali eksplorasi (lompatan besar), dan 200-an kali walk (langkah

kecil).

Kemudian, dicoba untuk memfaktorkan n = 437. Hasilnya adalah sebagai berikut.

Factoring n = 437

n = 437 L = [[37, 17]]

R = [31, 19]

W = [37, 11]

W = [41, 7]

W = [53, 7]

W = [31, 13]

W = [47, 5]

W = [19, 23]

success [19, 23]

running time 0.00304293632507 secs

Gambar 4.12 Pemfaktoran n = 437 dengan algoritma tabu search

Pada Gambar 4.12, terlihat bahwa untuk memfaktorkan n = 437 = 19* 23 dibutuhkan

waktu 0.00304293632507 detik, 1 kali eksplorasi (lompatan besar), dan 6 kali walk (langkah kecil).

Hasil ini juga cukup mengejutkan, karena untuk memfaktorkan modulus yang jauh lebih besar, algoritma tabu search juga justru membutuhkan waktu, walk, dan eksplorasi yang lebih sedikit. Namun, patut diketahui, bahwa algoritma ini juga sangat bergantung kepada pemilihan starting point, tabu list yang digunakan, dll. Dalam eksperimen lebih lanjut, ditemukan bahwa tabu search pada umumnya hanya dapat digunakan untuk memfaktorkan modulus RSA yang sangat kecil.

4.6. Hasil Algoritma Fermat

Berikut ini disajikan output algoritma Fermat untuk pemfaktoran n = 35, 143, 437, 3953, 9379, 27661, dan 1797253.

Fermat Difference of Squares Factorization Algorithm

n = 35

r = 6

s = 1

factors of 35 are [5, 7]

time = 0.00174999237061 secs

Fermat Difference of Squares Factorization Algorithm

n = 143

r = 12

s = 1

factors of 143 are [11, 13]

time = 0.00128507614136 secs

Fermat Difference of Squares Factorization Algorithm

n = 437

r = 21

s = 4

factors of 437 are [19, 23]

time = 0.00205087661743 secs

Fermat Difference of Squares Factorization Algorithm

n = 3953

r = 63

s = 16

factors of 3953 are [59, 67]

time = 0.00283908843994 secs

Fermat Difference of Squares Factorization Algorithm

n = 9379

r = 97

s = 30

r = 98

s = 225

factors of 9379 are [83, 113]

time = 0.00250101089478 secs

Fermat Difference of Squares Factorization Algorithm

n = 27661

r = 167

s = 228

r = 168

s = 563

r = 169

s = 900

factors of 27661 are [139, 199]

time = 0.000609159469604 secs

Fermat Difference of Squares Factorization Algorithm

n = 1797253

r = 1341

s = 1028

r = 1342

s = 3711

r = 1343

s = 6396

r = 1344

s = 9083

r = 1345

s = 11772

r = 1346

s = 14463

r = 1347

s = 17156

r = 1348

s = 19851

r = 1349

s = 22548

r = 1350

s = 25247

r = 1351

s = 27948

r = 1352

s = 30651

r = 1353

s = 33356

r = 1354

s = 36063

r = 1355

s = 38772

r = 1356

s = 41483

r = 1357

s = 44196

r = 1358

s = 46911

r = 1359

s = 49628

r = 1360

s = 52347

r = 1361

s = 55068

r = 1362

s = 57791

r = 1363

s = 60516

factors of 1797253 are [1117, 1609]

time = 0.0389270782471 secs

4.7. Hasil Algoritma Euler

Berikut ini disajikan output algoritma Euler untuk pemfaktoran n = 35, 143, 437, 3953, 9379, 27661, dan 1797253.

n = 35 a = 3 b = 2 p = 5 q = 7

iterations = 91

time = 0.00738096237183 secs

n = 143 a = 15 b = 8 p = 11 q = 13

iterations = 18

time = 0.00276803970337 secs

n = 437

time = 0.00354313850403 secs

n = 3953

time = 0.0181519985199 secs

n = 9379

time = 0.0165829658508 secs

n = 27661

time = 0.00785183906555 secs

n = 1797253

time = 0.112024068832 secs

Secara umum, dapat dinyatakan bahwa algoritma Euler memiliki performa kecepatan yang lebih buruk daripada Fermat.

4.8. Hasil Algoritma Brent

Berikut ini disajikan output algoritma Brent untuk pemfaktoran n = 35, 143, 437, 3953, 9379, 27661, 1797253, dan 21864876112579.

Brent Factorization Algorithm

35 = 7 * 5

time = 0.00217485427856 secs

Brent Factorization Algorithm

143 = 11 * 13

time = 0.000459909439087 secs

Brent Factorization Algorithm

437 = 19 * 23

time = 0.00461411476135 secs

Brent Factorization Algorithm

3953 = 67 * 59

time = 0.00339317321777 secs

Brent Factorization Algorithm

9379 = 113 * 83

time = 0.00347900390625 secs

Brent Factorization Algorithm

27661 = 199 * 139

time = 0.00395917892456 secs

Brent Factorization Algorithm

1797253 = 1609 * 1117

time = 0.0047869682312 secs

Brent Factorization Algorithm

21864876112579 = 3635447 * 6014357 time = 0.0419368743896 secs

Secara umum, dapat dinyatakan bahwa algoritma Brent memiliki performa kecepatan yang lebih baik daripada Euler.

4.9. Hasil Algoritma Pollard

Berikut ini disajikan output algoritma Pollard rho untuk pemfaktoran n = 35, 143, 437, 3953, 9379, 27661, dan 1797253.

Pollard Factorization Algorithm

Factoring RSA modulus n = 35

*input*

n = 35

*process*

Factoring 35 iterations = 1 a = 2 ^ 2 mod 35 = 4 d = gcd( 4 - 1, 35 ) = 1

Factoring 35 iterations = 2

a = 4 ^ 3 mod 35 = 29

d = gcd( 29 - 1, 35 ) = 7 is a factor Now, factoring 35 / 7 = 5

Factoring 5

5 is already a prime, thus it is a factor

*output*

n = 35 = 2 digits

n in binary = 100011 = 6 bits Factor of n = [5, 7]

Time = 0.0392229557037 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 143

*input*

n = 143

*process*

Factoring 143 iterations = 1

a = 2 ^ 2 mod 143 = 4 d = gcd( 4 - 1, 143 ) = 1

Factoring 143 iterations = 2

a = 4 ^ 3 mod 143 = 64 d = gcd( 64 - 1, 143 ) = 1

Factoring 143 iterations = 3

a = 64 ^ 4 mod 143 = 27

d = gcd( 27 - 1, 143 ) = 13 is a factor Now, factoring 143 / 13 = 11

Factoring 11

11 is already a prime, thus it is a factor

*output*

n = 143 = 3 digits

n in binary = 10001111 = 8 bits Factor of n = [11, 13]

Time = 0.0784590244293 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 437

*input*

n = 437

*process*

Time = 0.0763258934021 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 3953

*input*

n = 3953

*process*

Factoring 3953

n in binary = 111101110001 = 12 bits Factor of n = [59, 67]

Time = 0.15423989296 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 9379

*input*

d = gcd( 64 - 1, 9379 ) = 1

n in binary = 10010010100011 = 14 bits Factor of n = [83, 113]

Time = 0.00560402870178 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 27661

*input*

iterations = 10

a = 27185 ^ 11 mod 27661 = 25075

d = gcd( 25075 - 1, 27661 ) = 199 is a factor Now, factoring 27661 / 199 = 139

Factoring 139

139 is already a prime, thus it is a factor

*output*

n = 27661 = 5 digits

n in binary = 110110000001101 = 15 bits Factor of n = [139, 199]

Time = 0.134288072586 secs

Pollard Factorization Algorithm

Factoring RSA modulus n = 1797253

*input*

Now, factoring 1797253 / 1117 = 1609

Factoring 1609

1609 is already a prime, thus it is a factor

*output*

n = 1797253 = 7 digits

n in binary = 110110110110010000101 = 21 bits Factor of n = [1117, 1609]

Time = 0.447116851807 secs

4.10. Hasil Algoritma Pollard rho

Berikut ini disajikan output algoritma Pollard rho untuk pemfaktoran n = 35, 143, 437, 3953, 9379, 27661, 1797253, 21864876112579, dan 349220699384694583535650218727.