BAB IV

IMPLEMENTASI DAN PENGUJIAN

4.1 Implementasi

Implementasi merupakan tahapan lanjut dari tahapan perancangan sistem

untuk direalisasikan menjadi sebuah sistem nyata yang dapat beroperasi.
Implementasi dilakukan dengan mengubah rancangan yang ditulis pada bab III
menjadi sebuah program yang dapat dijalankan di komputer. Bahasa
pemrograman yang digunakan bahasa java. Socket yang diterapkan pada program
dioperasikan dengan jaringan local host.

4.1.1 Implementasi Perangkat Keras

Program hasil implementasi dijalankan pada sebuah komputer yang

memiliki spesifikasi perangkat keras (hardware) sebagai berikut:

1. Processor: AMD E-300 APU with Radeon™ HD Graphics 1.30 GHz

2. RAM 2 GB

4.1.2 Implementasi Perangkat Lunak

Perangkat lunak yang dipakai dalam penelitian ini digunakan untuk

pembuatan program komputer berbasis java. Spesifikasi perangkat lunak yang
digunakan adalah sebagai berikut:

1. Editor Java: Netbeans IDE versi 8.1

2. Kompiler Java: JDK versi 8.0 dan JRE versi 8.0
3. Sistem operasi: Windows 7 Ultimate 32 bit

4.1.3 Implementasi algoritma RSA standart

43
 Implementasi algoritma RSA standar dilakukan dengan membuat sebuah
class khusus yang diberi nama RSA_Standar. Class ini berisi fungsi (method)
untuk pembangkitan kunci, enkripsi, dan dekripsi. Implementasi ini sesuai dengan
rancangan algoritma RSA standar pada sub bab 3.2. Hasil implementasi ini
sebagai bahan uji perfoma dan keamanan algoritmanya.

4.1.3.1 Implementasi pembangkitan kunci algoritma RSA standar

Pembangkitan kunci algoritma RSA standar diimplementasikan dengan

membuat fungsi (method) pembangkit kunci. Implementasi ini sesuai dengan
pesudo code pada gambar 3.1 dengan pengaturan input yang berbeda. Fungsi ini
akan membentuk kunci publik dan kunci privat jika sudah dieksekusi. Kode
sumber pembangkitan kunci algoritma RSA standar adalah sebagai berikut:

public void pembangkitKunci(int panjang_bit, int panjang_bit_e){

BigInteger p, q, phi_n;

//memilih dua bilangan prima besar (p dan q)

while(true){

p = pembangkitPrima(panjang_bit);

q = pembangkitPrima(panjang_bit);

if(!p.equals(q))

break;

//menghitung nilai N dengan rumus 2.1

n = p.multiply(q);

//menghitung nilai Ф(N) pada rumus 2.2

phi_n =
(p.subtract(BigInteger.ONE)).multiply(q.subtract(BigInteger.ONE
));

//memilih bilangan bulat e dengan rumus 2.3

while(true){

if(panjang_bit_e != 0)

e = new BigInteger(phi_n.bitLength()-panjang_bit_e, new

44
 Random());

else

e = new BigInteger(panjang_bit, new Random());

if((e.gcd(phi_n)).equals(BigInteger.ONE))

break;

//menghitung eksponen dekripsi d dengan rumus 2.4

d = e.modInverse(phi_n);

Gambar 4.1: kode sumber pembangkitan kunci algoritma RSA standar

Variabel p dan q pada gambar 4.1 diatas menunjukkan bilangan prima. Variabel n
menunjukkan nilai N atau modulus sesuai dengan rumus 2.1. Variabel phi_n
menunjukkan nilai Ф(N) atau euler totient function sesuai dengan rumus 2.2.
Variabel e menunjukkan eksponen enkripsi sesuai dengan rumus 2.3. Variabel d
menunjukkan eksponen dekripsi sesuai dengan rumus 2.4. Parameter panjang_bit
menunjukkan panjang bit bilangan prima sedangkan parameter panjang_bit_e
menunjukkan panjang bit eksponen enkripsi.

4.1.3.2 Implementasi enkripsi RSA standar

Enkripsi algoritma RSA standar diimplementasikan dengan membuat

fungsi (method) enkripsi. Fungsi ini akan mengubah pesan asli menjadi pesan
terenkripsi. Implementasi enkripsi RSA standar ini sesuai dengan pseudo code
pada gambar 3.3. Kode sumber enkripsi algoritma RSA adalah sebagai berikut:

public String enkripsi(BigInteger E, BigInteger N, String plaintext){

String ciphertext = "";

for(int i=0; i<plaintext.length(); i++){

//konversi nilai Mi ke desimal

45
 int ASCII = (int)plaintext.charAt(i);

//menghitung nilai C dengan rumus 2.5

BigInteger C = BigInteger.valueOf(ASCII).modPow(E, N);

ciphertext = ciphertext+C.toString()+" ";

return ciphertext;

Gambar 4.2: kode sumber enkripsi algoritma RSA standar

Parameter plaintext pada Gambar 4.2 diatas merupakan pesan asli yang ditulis
oleh user. Variabel ASCII menunjukkan nilai desimal karakter sebagai nilai plain
text (M). Parameter E menunjukkan eksponen enkripsi (e). Parameter N
menunjukkan nilai modulus (N). Variabel C menunjukkan nilai cipher text (C).
Variabel-variabel ini sesuai dengan rumus 2.5. Nilai cipher text tiap karakter
disimpan pada variabel ciphertext. Nilai yang tersimpan pada variabel ciphertext
ini nantinya dikirim ke user tujuan melalui socket TCP.

4.1.3.3 Implementasi dekripsi algoritma RSA standar

Dekripsi algoritma RSA diimplementasikan dengan membuat fungsi

(method) dekripsi. Fungsi ini digunakan untuk mengembalikan pesan terenkripsi
menjadi pesan asli. Kunci privat untuk proses dekripsi diinputkan secara langsung
pada fungsi ini. Implementasi dekripsi algoritma RSA standar ini sesuai dengan
pseudo code pada gambar 3.5. Kode sumber dekripsi algoritma RSA standar
adalah sebagai berikut:

public String dekripsi(String ciphertext){

String plaintext="";

46
 String temp="";

for(int i=0; i<ciphertext.length(); i++){

if((ciphertext.charAt(i)+"").equals(" ")){

//menghitung nilai M dengan rumus 2.6

BigInteger M = (new BigInteger(temp)).modPow(d, n);

//konversi nilai M ke karakter

byte ASCII = Byte.parseByte(M.toString());

plaintext = plaintext+(char)ASCII;

temp="";

}else{

temp=temp+ciphertext.charAt(i);

return plaintext;

Gambar 4.3: kode sumber dekripsi algoritma RSA standar

Variabel M pada gambar 4.3 diatas menunjukkan nilai plain text (M). Variabel
temp menunjukkan nilai cipher text (C). Variabel d menunjukkan nilai eksponen
dekripsi (d). Variabel N menunjukkan nilai modulus (N). Variabel-variabel ini
sesuai dengan rumus 2.6. Parameter ciphertext menunjukkan pesan terenkripsi
yang berisi kumpulan nilai C tiap karakter pada pesan asli. Karakter hasil konversi
nilai variabel M tiap cipher text ditampung pada variabel plaintext. Variabel
plaintext akan menyimpan pesan asli hasil dekripsi jika proses dekripsi selesai.

4.1.4 Implementasi improvisasi algoritma RSA

Improvisasi algoritma RSA diimplementasikan kedalam sebuah class

khusus yang diberi nama Improvisasi_RSA. Class ini berisi fungsi untuk
melakukan pembangkitan kunci, enkripsi, dan dekripsi. Implementasi ini sesuai
dengan rancangan improvisasi algoritma RSA pada sub bab 3.3.

47
4.1.4.1 Implementasi pembangkitan kunci improvisasi algoritma RSA

Pembangkitan kunci improvisasi algoritma RSA diimplementasikan

dengan membuat fungsi (method) pembangkit kunci. Fungsi ini akan membentuk
kunci publik dan kunci privat jika sudaha dieksekusi. Implementasi pembangkitan
kunci improvisasi algoritma RSA ini sesuai dengan pseudo code pada gambar 3.7.
Kode sumber pembangkit kunci improvisasi algoritma RSA adalah sebagai
berikut:

public void pembangkitKunci(int panjang_bit, int jumlah_prima, int

panjang_bit_e){

BigInteger[] daftar_bilangan_prima = new

BigInteger[jumlah_prima];

//membangkitkan sejumlah bilangan prima

while(true){

for(int i=0; i<daftar_bilangan_prima.length; i++){

daftar_bilangan_prima[i] = pembangkitPrima(panjang_bit);

if(verifikasiDaftarBilanganPrima(daftar_bilangan_prima))

break;

n = BigInteger.ONE;

BigInteger phi_n = BigInteger.ONE;

for (BigInteger daftar_bilangan_prima1 : daftar_bilangan_prima)

{

//menghitung nilai N dengan rumus 2.11

n = n.multiply(daftar_bilangan_prima1);

//menghitung nilai Ф(N) dengan rumus 2.12

phi_n =
phi_n.multiply(daftar_bilangan_prima1.subtract(BigInteger.ONE));

//memilih bilangan bulat e dengan 2.13

while(true){

if(panjang_bit_e != 0)

48
 e = new BigInteger(phi_n.bitLength()-panjang_bit_e, new
Random());

else

e = new BigInteger(panjang_bit, new Random());

if((e.gcd(phi_n)).equals(BigInteger.ONE))

break;

//menghitung nilai d dengan rumus 2.14

d = e.modInverse(phi_n);

Gambar 4.4: kode sumber pembangkitan kunci improvisasi algoritma RSA

Variabel daftar_bilangan_prima pada gambar 4.4 diatas menunjukkan bilangan

prima (p1, p2, …, pn) yang jumlahnya sesuai dengan jumlah bilangan prima yang
dibangkitkan. Variabel n menunjukkan nilai modulus (N) sesuai dengan rumus
2.11. Variabel phi_n menunjukkan nilai Ф(N) atau euler totient function sesuai
dengan rumus 2.12. Variabel e menunjukkan eksponen enkripsi (e) sesuai dengan
rumus 2.13. Variabel d menunjukkan eksponen dekripsi (d) sesuai dengan rumus
2.14. Parameter panjang_bit menunjukkan panjang bit bilangan prima. Parameter
jumlah_prima menunjukkan jumlah bilangan prima yang dibangkitan. Parameter
panjang_bit_e menunjukkan panjang bit eksponen enkripsi.

4.1.4.2 Implementasi enkripsi improvisasi algoritma RSA

Enkripsi improvisasi algoritma RSA diimplementasikan dengan membuat

fungsi (method) enkripsi. Fungsi ini digunakan untuk mengubah pesan asli
menjadi pesan terenkripsi. Implementasi enkripsi improvisasi algoritma RSA ini
sesuai dengan pseudo code pada gambar 3.7. Kode sumber enkripsi improvisasi
algoritma RSA adalah sebagai berikut:

49
public String enkripsi(BigInteger E, BigInteger N, String
plaintext){

BigInteger k;

while(true){

//memilih bilangan acak k dengan rumus 2.15

k = new BigInteger(N.bitLength(), new Random());

if((k.gcd(N)).equals(BigInteger.ONE))

break;

//menghitung cipher text k (Ck) dengan rumus 2.16

BigInteger Ck = k.modPow(E, N);

String cipherteks=Ck.toString()+" ";

for(int i=0; i<plaintext.length(); i++){

int ASCII = (int)plaintext.charAt(i);

//menghitung nilai C dengan rumus 2.17

BigInteger C = BigInteger.valueOf(ASCII).modPow(E, N);

C = C.multiply(k).mod(N);

cipherteks = cipherteks+C.toString()+" ";

return cipherteks;

Gambar 4.5: kode sumber enkripsi improvisasi algoritma RSA

Variabel E pada gambar 4.5 diatas menunjukkan nilai eksponen enkripsi (e).
Variabel N menunjukkan nilai modulus (N). Variabel k menunjukkan bilangan
bulat acak sesuai dengan rumus 2.15. Variabel Ck menunjukkan cipher text k (Ck)
sesuai dengan rumus 2.16. Variabel ASCII menunjukkan nilai desimal karakter
sebagai plain text (M). Variabel C menunjukkan nilai cipher text (C) sesuai
dengan rumus 2.17. Parameter plaintext menunjukkan pesan asli yang ditulis oleh
user. Nilai cipher text k dan nilai cipher text tiap karakter dalam pesan asli
disimpan pada variabel cipherteks. Nilai variabel cipherteks ini nantinya
dikirimkan ke user lain melalui socket TCP.

50
4.1.4.3 Implementasi dekripsi improvisasi algoritma RSA

Dekripsi improvisasi algoritma RSA diimplementasikan dengan membuat

fungsi (method) dekripsi. Fungsi ini digunakan untuk mengembalikan pesan
terenkripsi menjadi pesan asli. Implementasi dekripsi improvisasi algoritma RSA
sesuai dengan pseudo code pada gambar 3.11. Kode sumber dekripsi improvisasi
algoritma RSA adalah sebagai berikut:

public String dekripsi(String cipher){

String Ck="";

int i=0;

while(true){

if((cipher.charAt(i)+"").equals(" "))

break;

else

Ck=Ck+cipher.charAt(i);

i++;

//menghitung nilai k dengan rumus 2.18

BigInteger k = (new BigInteger(Ck)).modPow(d, n);

//menghitung nilai t dengan rumus 2.19

BigInteger t = k.modInverse(n);

String plain="";

String temp="";

for(i++; i<cipher.length(); i++){

if((cipher.charAt(i)+"").equals(" ")){

BigInteger C = new BigInteger(temp);

//menghitung M dengan rumus 2.20

BigInteger M = (C.multiply(t)).modPow(d, n);

51
 byte ASCII = Byte.parseByte(M.toString());

plain = plain+(char)ASCII;

temp="";

}else{

temp = temp+cipher.charAt(i);

return plain;

Gambar 4.6: kode sumber dekripsi improvisasi algoritma RSA

Variabel Ck pada gambar 4.6 diatas menunjukkan cipher text k (Ck). Variabel d
menunjukkan nilai eksponen dekripsi (d). Variabel n menunjukkan nilai modulus
(N). Variabel k menunjukkan nilai bilangan bulat sesuai dengan rumus 2.18.
Variabel t menunjukkan nilai bilangan bulat sesuai dengan rumus 2.19. Variabel M
menunjukkan nilai plain text sesuai dengan rumus 2.20. Variabel ASCII
menyimpan hasil konversi nilai M ke karakter. Hasil konversi tiap nilai M ini
disimpan dalam variabel plain. Variabel plain ini nantinya menyimpan pesan asli
jika proses dekripsi selesai.

4.1.5 Implementasi known plain text attack

Metode known plain text attack diimplementasikan dengan membuat

sebuah program khusus yang ditulis dengan bahasa pemrograman java.
Implementasi ini sesuai dengan rancangan pada gambar 3.13. Program ini
menerima inputan berupa kunci publik (N,e) dan cipher text (C). Program ini akan
menampilkan pesan asli dari cipher text jika terdapat nilai C yang
berkorespodensi. Kode sumber metode known plain text attack adalah sebagai
berikut:

52
btn_cek.addActionListener((ActionEvent e) -> {

try{

long start = System.currentTimeMillis();

//mengambil inputan kunci publik (N,e)

BigInteger E = new BigInteger(ta1.getText());

BigInteger N = new BigInteger(ta2.getText());

//mengambil inputan pesan terenkripsi

String ciphertext = ta3.getText()+" ";

//membuat himpunan P dan C

ArrayList<BigInteger> data_cipher = new ArrayList<>();

int data_ASCII[] = new int[256];

for(int i=0; i<256; i++){

data_cipher.add(BigInteger.valueOf(i).modPow(E, N));

data_ASCII[i] = i;

String temp="";

String plaintext1="";

String plaintext2="";

int jumlah_cipher = 0;

int jumlah_plain = 0;

//memeriksa kecocokan himpunan (P,C) dengan pesan terenkripsi

for(int i=0; i<ciphertext.length(); i++){

if((ciphertext.charAt(i)+"").equals(" ")){

if(!temp.equals("")){

BigInteger C = new BigInteger(temp);

for(int j=0; j<256; j++){

//menemukan nilai C yang cocok

if(C.equals(data_cipher.get(j))){

//menampung nilai P yang bersesuaian

plaintext1 = plaintext1+data_ASCII[j]+" ";

53
 //mengubah nilai P menjadi karakter

plaintext2 = plaintext2+(char)data_ASCII[j];

jumlah_plain++;

break;

jumlah_cipher++;

temp="";

}else

temp=temp+ciphertext.charAt(i);

long waktu = System.currentTimeMillis()-start;

ta4.setText("");

if(!plaintext1.equals("")){

//menampilkan informasi yang ditemukan saat berhasil

ta4.append("Plaintext yang ditemukan:\n\n");

ta4.append("Plaintext angka : "+plaintext1+"\n");

ta4.append("Plaintext ASCII : "+plaintext2+"\n\n");

}else{

//hasil gagal

ta4.append("Plaintext tidak dapat ditemukan\n\n");

ta4.append("Total ciphertext yang dianalisa = "+jumlah_cipher+"\n");

ta4.append("Total plaintext yang ditemukan = "+jumlah_plain+"\n");

ta4.append("Waktu analisa : "+waktu+" milisecond\n");

}catch(Exception ex){

JOptionPane.showMessageDialog(rootPane, "Terjadi kesalahan :

"+ex.getMessage(), "error", JOptionPane.ERROR_MESSAGE);

54
 });

Gambar 4.7: potongan kode sumber aplikasi known plain text test RSA

Variabel E pada gambar 4.7 diatas menunjukkan ekspoenen enkripsi. Variabel N

menunjukkan nilai modulus (N). Variabel ciphertext menunjukkan pesan
terenkripsi yang terdiri dari sekumpulan nilai cipher text (C). Variabel data_cipher
menyimpan kumpulan data cipher text dan variabel data_ASCII menyimpan
kumpulan data ASCII desimal sebagai kumpulan data plain text. Kumpulan data
cipher text dan data plain text ini nantinya digunakan untuk menganalisis pesan
terenkripsi.

4.1.6 Implementasi Wiener attack

Wiener attack diimplementasikan dengan membuat program khusus yang

ditulis dengan bahasa pemrograman java. Wiener attack memiliki dua sub proses
yang harus dikerjakan terlebih dahulu. Sub proses pertama adalah membentuk
fraksaksi berkelanjutan. Sub proses ini dimplementasikan dengan membuat fungsi
(method) continue_fraction. Sub proses pertama sesuai dengan pseudo code pada
gambar 3.14. Kode sumber sub proses pertama adalah sebagai berikut:

private void continue_fraction(BigInteger e, BigInteger n){

//membentuk fraksaksi berkelanjutan dengan rumus 2.7

q_n.add(e.divide(n));

BigInteger r = e.mod(n);

e = n;

n = r;

while(!r.equals(BigInteger.ZERO)){

//membentuk fraksaksi berkelanjutan dengan rumus 2.7

q_n.add(e.divide(n));

r = e.mod(n);

55
 e = n;

n = r;

Gambar 4.8: kode sumber method pembuat fraksaksi berkelanjutan

Variabel q_n pada gambar 4.8 diatas merupakan elemen fraksaksi berkelanjutan
sesuai dengan rumus 2.7. Variabel e menunjukkan nilai eksponen enkripsi (e).
Variabel n menunjukkan nilai modulus (N). Variabel r menunjukkan sisa hasil
pembagian nilai variabel e dengan nilai variabel n. Sub proses berikutnya adalah
membentuk fraksaksi k/d. Sub proses ini dimplementasikan dengan membuat
fungsi (method) fraction_to_fraction. Implementasi ini sesuai dengan pseudo code
pada gambar 3.15. Kode sumber pembentuk fraksaksi k/d adalah sebagai berikut:

private void fraction_to_fraction(){

//membentuk fraksaksi k/d sesuai rumus 2.8

k_n.add(q_n.get(0));

d_n.add(BigInteger.ONE);

k_n.add(q_n.get(0).multiply(q_n.get(1)).add(BigInteger.ONE));

d_n.add(q_n.get(1));

for(int i=2; i<q_n.size(); i++){

k_n.add(q_n.get(i).multiply(k_n.get(i-1)).add(k_n.get(i-2)));

d_n.add(q_n.get(i).multiply(d_n.get(i-1)).add(d_n.get(i-2)));

Gambar 4.9: kode sumber method pembentuk fraksaksi k/d

Variabel k_n dan d_n menunjukkan nilai fraksaksi (k dan d) sesuai dengan rumus
2.8. Variabel k_n menyimpan kumpulan nilai fraksaksi k, sedangkan variabel d_n

56
menyimpan kumpulan nilai fraksaksi d. Metode wiener attack diimplementasikan
dengan membuat fungsi wiener_test. Implementasi ini sesuai dengan pseudo code
pada gambar 3.16. Kode sumber metode wiener attack adalah sebagai berikut:

public BigInteger Wiener_test(BigInteger e, BigInteger N){

continue_fraction(e,N);

fraction_to_fraction();

for(int i=1; i<d_n.size(); i++){

//menghitung nilai Ф(N) sesuai rumus 2.9

BigInteger phi_n =
(e.multiply(d_n.get(i)).subtract(BigInteger.ONE)).divide(k_n.get(i));

if(!phi_n.equals(BigInteger.ZERO)){

//menyelsaikan persamaan kuadrat sesuai rumus 2.10

BigInteger b = N.subtract(phi_n).add(BigInteger.ONE);

BigInteger D = (b.pow(2)).subtract(BigInteger.valueOf(4).multiply(N));

BigInteger x1 = (b.add(sqrt(D))).divide(BigInteger.valueOf(2));

BigInteger x2 = (b.subtract(sqrt(D))).divide(BigInteger.valueOf(2));

if((x1.multiply(x2)).equals(N)){

//menhitung nilai d dengan rumus 2.4

BigInteger d = e.modInverse(phi_n);

return d;

return BigInteger.ZERO;

Gambar 4.10: kode sumber method uji wiener attack

57
Variabel phi_n pada gambar 4.10 diatas menunjukkan nilai Ф(N) atau euler totient
function. Variabel e menunjukkan nilai eksponen enkripsi (e). Variabel N
menunjukkan nilai modulus (N). Variabel-variabel ini sesuai dengan rumus 2.9.
Variabel ini juga digunakan untuk proses penyelesaian persamaan kuadrat sesuai
dengan rumus 2.10. Variabel x1 dan x2 menyimpan nilai hasil akar persamaan
kuadrat sesuai dengan acuan rumus 2.10. Hasil kali antara nilai variabel x1 dan
nilai variabel x2 yang nilainya sama dengan nilai variabel N menunjukkan wiener
attack berhasil menemukan nilai eksponen dekripsi (d). Variabel d menunjukkan
eksponen dekripsi (d). Nilai variabel ini dihitung dengan rumus 2.4

4.2 Pengujian

Pengujian merupakan proses uji yang dilakukan setelah melakukan

implementasi. Pengujian dilakukan untuk menguji perfoma dan keamanan
algoritma RSA standar dan improvisasi algoritma RSA. Pengujian perfoma
meliputi pengujian waktu pembangkitan kunci, enkripsi, dekripsi dan waktu
pengiriman pesan sedangkan pengujian keamanan dilakukan dengan metode
known plain text attack dan wiener attack.

4.2.1 Pengujian waktu pembangkitan kunci

Pengujian waktu pembangkitan kunci dilakukan dengan mengamati

waktu yang diperlukan algoritma untuk membentuk kunci publik dan kunci privat.
Skenario pengujian ini sudah dijelaskan pada sub bab 1.5.4 poin ke 1.

4.2.1.1 Pengujian waktu pembangkitan kunci algoritma RSA standar

Pengujian waktu pembangkitan kunci pada algoritma RSA standar

dilakukan dalam beberapa kali pengujian dengan pengaturan panjang bit bilangan
prima dan panjang bit eksponen enkripsi yang berbeda. Hasil pengujian ini secara
keseluruhan dapat dilihat di lampiran 1. Hasil pengujian waktu pembangkitan

58
kunci dengan parameter panjang bit bilangan prima 128 bit dan panjang bit
eksponen enkripsi 128 bit adalah sebagai berikut:

Tabel 4.1: Hasil pengujian prima 128 bit

Percobaan ke Waktu pembangkitan kunci (ms)

1 63

2 78

3 31

4 62

5 32

Hasil pengujian pada tabel 4.1 menyimpulkan bahwa waktu pembangkitan kunci
terlihat tidak menentu. Hal ini dipengarui oleh kecepatan sistem dalam
membangkitkan bilangan prima. Mula-mula sistem membangkitkan bilangan
ganjil secara acak dengan panjang bit yang sudah diberikan kemudian dilakukan
serangkaian pengujian untuk menentukan status keprimaan bilangan. Jika uji
keprimaan algoritma miller rabin bernilai true maka proses pembangkitan
bilangan prima selesai, sebaliknya jika uji keprimaan algoritma miller rabin
bernilai false maka sistem mengulang proses pembangkitan bilangan prima dari
awal.

4.2.1.2 Pengujian waktu pembangkitan kunci improvisasi algoritma RSA

Pengujian waktu pembangkitan pada improvisasi algoritma RSA

dilakukan dilakukan dalam beberapa kali pengujian dengan pengaturan panjang
bit bilangan prima dan panjang bit eskponen enkripsi yang berbeda. Hasil
pengujian ini secara keseluruhan dapat dilihat di lampiran 2. Jumlah bilangan
prima yang digunakan oleh improvisasi algoritma RSA adalah 2 hingga 6

59
bilangan prima. Hasil pengujian waktu pembangkitan kunci improvisasi algoritma
RSA dengan parameter panjang bit bilangan prima 128 bit dan panjang bit
eksponen enkripsi 128 bit adalah sebagai berikut:

Tabel 4.2: Hasil pengujian prima 128 bit

Waktu pembangkitan kunci (ms)

Percobaan ke
2 3 4 5 6

1 141 62 47 109 110

2 47 125 63 94 171

3 78 47 125 124 125

4 16 78 78 141 156

5 16 47 124 125 125

60
Ada beberapa poin analisa yang dapat diambil dari tabel 4.2 diatas. Waktu
pembangkitan kunci terlihat tidak menentu, hal ini dipengarui oleh proses
pembangkitan bilangan prima. Algoritma miller-rabin bersifat probabilistik
sehingga diperlukan beberapa kali pengujian untuk mendapatkan bilangan yang

Grafik pembangkitan kunci improvisasi algoritma

RSA
200

150

100

50

0
1 2 3 4 5

IRSA (2 prima) IRSA (3 prima) IRSA (4 prima)

IRSA (5 prima) IRSA (6 prima)

hampir prima. Semakin banyak bilangan prima yang digunkan, semakin tinggi
rentang waktu pembangkitan kunci yang diperlukan. Improvisasi algoritma RSA
yang menggunakan 2 bilangan prima memiliki waktu pembangkitan kunci yang
lebih cepat dibandingkan improvisasi algoritma RSA yang menggunakan 6
bilangan prima. Grafik waktu pembangkitan kunci dari tabel 4.1 adalah sebagai
berikut:

Gambar 4.11: Grafik pengujian prima 128 bit

Poin analisa yang dapat diambil dari gambar 4.11 yaitu semakin banyak bilangan
prima yang digunakan, waktu pembangkitan kunci semakin lama. Hal ini terlihat
pada grafik 4.1 dimana garis yang mewakili improvisasi algoritma RSA yang
menggunakan 2 bilangan prima menempati posisi bawah sedangkan improvisasi
algoritma RSA yang menggunakan 6 bilangan prima menempati posisi atas.

4.2.1.3 Analisis perbandingan waktu pembangkitan kunci

61
 Analisis perbandingan hasil pengujian waktu pembangkitan kunci
dilakukan dengan membandingkan rata-rata waktu pembangkitan kunci pada tiap
panjang bit bilangan prima dan panjang bit eksponen enkripsi (e). Perbandingan
ini dilakukan untuk menganalisis perfoma waktu pembangkitan kunci antara
algoritma RSA standar dan improvisasi algoritma RSA (IRSA). Perbandingan
rata-rata waktu pembangkitan kunci dengan parameter panjang prima 128 bit
adalah sebagai berikut:

Tabel 4.3: Perbandingan rata-rata waktu pembangkitan kunci prima 128 bit

Algoritma Default Panjang bit Panjang bit Panjang bit

(ms) nilai Ф(N) - 4 nilai Ф(N) - 3 nilai Ф(N) - 2
(ms) (ms)
(ms)

Algoritma RSA 53.2 56.2 84.2 109

standar

IRSA (2 prima) 59.6 46.8 46.6 56.4

IRSA (3 prima) 71.8 78 66.6 83.2

IRSA (4 prima) 87.4 90.6 87.2 84.8

IRSA (5 prima) 118.6 106.2 101.8 134.6

IRSA (6 prima) 137.4 131.2 153 226

Rata-rata 88 84.8333 89.9 115.6667

Kesimpulan yang dapat diambil dari tabel 4.3 yaitu waktu pembangkitan kunci
algoritma RSA tidak selalu lebih cepat dari improvisasi algoritma RSA. Waktu
pembangkitan kunci improvisasi algoritma RSA yang menggunakan 2 bilangan
prima lebih cepat daripada algoritma RSA standar pada beberapa parameter
panjang bit eksponen enkripsi yang sama seperti pada parameter panjang bit nilai
Ф(N) dikurangi 4 hingga 2. Hal ini membuktikan bahwa implementasi

62
pembangkitan kunci yang berbeda memperngarui waktu pembangkitan kunci
algoritma meskipun secara konsep sama. Waktu pembangkitan kunci improvisasi
algoritma RSA yang menggunakan 5 dan 6 bilangan prima lebih lama
dibandingkan dengan waktu pembangkitan kunci algoritma RSA standar. Hasil ini
membuktikan bahwa penambahan jumlah penggunaan bilangan prima pada
improvisasi algoritma RSA meningkatkan waktu pembangkitan kunci.
Penggunaan jumlah bilangan prima yang lebih sedikit dapat mengurangi waktu
pembangkitan kunci improvisasi algoritma RSA. Perbandingan rata-rata waktu
pembangkitan kunci dengan parameter prima 256 bit adalah sebagai berikut:

Tabel 4.4: Perbandingan rata-rata waktu pembangkitan kunci prima 256 bit

Algoritma Default Panjang bit Panjang bit Panjang bit

(ms) nilai Ф(N) - 4 nilai Ф(N) - 3 nilai Ф(N) - 2
(ms) (ms) (ms)

Algoritma RSA 790.2 633.2 1076.2 692.3

standar

IRSA (2 prima) 430.6 409.4 393 404.2

IRSA (3 prima) 446 655.4 820.8 1036.8

IRSA (4 prima) 1631.8 892.4 964.2 1050

IRSA (5 prima) 2630.4 1098.2 1285.8 1427.2

IRSA (6 prima) 2817 1432 1688 1292

Rata-rata 1457.667 853.4333 1037.9667 983.75

63
Kesimpulan yang dapat diambil dari tabel 4.4 yaitu waktu pembangkitan kunci
improvisasi algoritma RSA yang menggunakan 2 bilangan prima lebih cepat
dibandingkan algoritma RSA standar. Improvisasi algoritma RSA yang
menggunakan 2 bilangan prima memiliki konsep yang sama dengan algoritma
RSA standar namun memiliki implementasi yang berbeda dari segi kode sumber.
Waktu pembangkitan improvisasi algoritma RSA yang menggunakan 4 hingga 6
bilangan prima lebih lambat dibandingkan algoritma RSA standar. Hasil ini
membuktikan bahwa peningkatan jumlah penggunaan bilangan prima dapat
memperlambat waktu pembangkitan kunci improvisasi algoritma RSA.

Hasil perbandingan rata-rata waktu pembangkitan kunci pada tabel 4.3

dan tabel 4.4 diatas menyimpulkan bahwa:

1. Panjang bit eksponen enkripsi (e) tidak berpengaruh secara signifikan pada
perfoma waktu pembangkitan kunci. Hal ini ditunjukkan pada tabel 4.3
dimana semakin besar panjang bit nilai e, rata-rata waktu pembangkitan kunci
tidak semakin meningkat atau menurun secara drastis.

2. Improvisasi algoritma RSA yang menggunakan 2 bilangan prima menjadi

algoritma tercepat dalam melakukan pembangkitan pada semua pengujian
kecuali pada pengujian dengan parameter panjang prima 128 bit dan panjang
bit nilai e sama dengan 128 bit (default). Hasil ini membuktikan bahwa
implementasi memperngarui waktu eksekusi program.

3. Improvisasi algoritma RSA yang menggunakan 5 dan 6 bilangan prima

terbukti lebih lambat daripada algoritma RSA standar dalam melakukan
pembangkitan kunci.

4. Panjang bit bilangan prima memperngarui cepat lambatnya waktu

pembangkitan kunci. Peningkatan panjang bit bilangan prima akan
meningkatkan waktu pembangkitan kunci, hal ini dilihat dari data yang
ditampilkan pada tabel 4.3 yang nilai rata-ratanya lebih rendah dibandingkan
nilai rata-rata pada tabel 4.4.

64
4.2.2 Pengujian waktu enkripsi

Pengujian waktu enkripsi dilakukan dengan mengamati waktu yang

diperlukan algoritma untuk mengubah pesan asli menjadi pesan terenkripsi.
Skenario pengujian ini sesuai dengan sub bab 1.5.4 poin 1.

4.2.2.1 Pengujian waktu enkripsi algoritma RSA standar

Pengujian waktu enkripsi pada algoritma RSA standar dilakukan dalam

beberapa kali pengujian dengan pengaturan parameter panjang bit bilangan prima
dan panjang bit eksponen enkripsi yang berbeda. Hasil pengujian keseluruhan
dapat dilihat di lampiran 3. Hasil pengujian waktu enkripsi algoritma RSA standar
dengan parameter bilangan prima 128 bit adalah sebagai berikut:

Tabel 4.5: Hasil pengujian waktu enkripsi prima 128 bit

No Panjang Default Panjang bit Panjang bit Panjang bit

karakter (ms) nilai Ф(N) - 4 nilai Ф(N) - 3 nilai Ф(N) - 2
(ms) (ms) (ms)

1 50 31 78 78 62

2 100 93 140 156 140

3 160 124 234 234 250

Ada beberapa poin analisa dari hasil pengujian waktu enkripsi pada tabel 4.5 yang
sebagai berikut:

1. Panjang bit nilai eksponen enkripsi (e) memperngarui perfoma waktu

enkripsi. Peningkatan panjang bit eksponen enkripsi menyebabkan
peningkatan waktu enkripsi algoritma RSA stnadar, hal ini terlihat pada
parameter default dan panjang bit nilai Ф(N) - 2 pada tabel 4.5 yang selalu

65
 terjadi peningkatan waktu enkripsi. Pengujian dengan parameter panjang bit
eksponen enkripsi sama dengan panjang bilangan yang dibangkitkan
memiliki waktu enkripsi yang lebih cepat dibandingkan dengan parameter
panjang bit eksponen enkripsi yang lain. Hasil ini menunjukkan pengaruh
panjang bit eksponen enkripsi.

2. Panjang karakter pesan asli yang dienkripsi memperngarui waktu enkripsi.

Peningkatan jumlah karakter pesan asli menyebabkan peningkatan waktu
enkripsi algoritma RSA standar, hal ini cukup jelas karena algoritma
menenkripsi setiap karakter dalam pesan membutuhkan waktu tertentu
sehingga panjang karakter dapat meningkatkan waktu enkripsi.

3. Parameter panjang bit eksponen enkripsi (e) sebesar panjang bit nilai Ф(N)
dikurangi 4 hingga 2 menghasilkan panjang bit yang tidak menentu. Jika
ukuran bilangan prima sebesar 128 bit maka kemungkinan panjang bit nilai
Ф(N) adalah 256 bit atau 255 bit. Hal ini menyebabkan ketidakpastian
panjang bit nilai e sehingga waktu enkripsi yang ditampilkan pada parameter
ini hampir sama atau memiliki selisih yang rendah.

4.2.2.2 Pengujian waktu enkripsi improvisasi algoritma RSA

Pengujian waktu enkripsi pada improvisasi algoritma RSA dilakukan

dalam beberapa kali pengujian dengan pengaturan parameter panjang bit bilangan
prima dan panjang bit eksponen enkripsi yang berbeda. Hasil pengujian
keseluruhan dapat dilihat di lampiran 4. Hasil pengujian waktu enkripsi
improvisasi algoritma RSA dengan parameter bilangan prima 128 bit adalah
sebagai berikut:

Tabel 4.6: Hasil pengujian waktu enkripsi prima 128 bit

Jumlah Panjang Default Panjang Panjang Panjang

No Bilangan karakter (ms) bit nilai bit nilai bit nilai
Ф(N) - 4 Ф(N) - 3 Ф(N) - 2

66
 prima (ms) (ms) (ms)

2 47 93 78 78

3 95 219 207 227

1 4 50 125 468 484 452

5 203 874 858 874

6 281 1435 1467 1482

2 78 156 156 156

3 165 424 442 442

2 4 100 265 921 936 952

5 406 1748 1763 1763

6 546 2845 2948 2933

2 140 249 243 265

3 277 734 693 761

3 4 150 421 1482 1514 1513

5 656 2808 2777 2792

6 889 4617 4743 4680

Ada beberapa poin analisa dari hasil pengujian waktu enkripsi pada tabel 4.5 yang
sebagai berikut:

1. Jumlah penggunaan bilangan prima memperngarui waktu enkripsi.

Peningkatan jumlah penggunaan bilangan prima menyebabkan peningkatan
waktu enkripsi. Waktu enkripsi paling lama terjadi pada improvisasi
algoritma RSA yang menggunakan 6 bilangan prima, sedangkan waktu
enkripsi paling cepat terjadi pada improvisasi algoritma RSA yang

67
 menggunakan 2 bilangan prima. Waktu enkripsi improvisasi algoritma RSA
yang menggunakan 2 hingga 6 bilangan prima terlihat selalu mengalami
peningkatan.

2. Nilai Ф(N) pada improvisasi algoritma RSA dihitung sesuai dengan rumus
2.12. Peningkatan jumlah penggunaan bilangan prima menyebabkan nilai
Ф(N) semakin besar sehingga panjang bit yang dihasilkan semakin besar.
Faktor ini berdampak ketika panjang bit nilai e setara dengan panjang bit nilai
Ф(N) dikurangi 2 hingga 4. Improvisasi algoritma RSA yang menggunakan 2
bilangan prima tidak mengalami kenaikan waktu enkripsi yang cukup besar
dari parameter default hingga panjang bit nilai Ф(N) dikurangi 4 sedangkan
improvisasi algoritma RSA yang menggunakan 6 bilangan prima mengalami
kenaikan waktu enkripsi yang sangat besar dari parameter default hingga
panjang bit nilai Ф(N) dikurangi 4.

3. Panjang karakter pesan asli memperngarui waktu enkripsi. Peningkatan

jumlah karakter pada pesan asli menyebabkan peningkatan waktu enkripsi,
hal ini dikarenakan algoritma mengenkripsi setiap karakter pada pesan asli
dengan estimasi waktu tertentu.

4.2.2.3 Analisis perbandingan waktu enkripsi

Analisis waktu enkripsi dilakukan dengan membandingkan nilai rata-rata

waktu enkripsi antara algoritma RSA standar dan improvisasi algoritma RSA pada
tiap panjang karakter pesan. Nilai rata-rata waktu enkripsi diambil mulai dari
parameter panjang bit nilai e setara dengan panjang bit bilangan prima yang
dibangkitkan (default) hingga setara dengan panjang bit nilai Ф(N) dikurangi 2.
Hasil perbandingan rata-rata waktu enkripsi algoritma RSA dan improvisasi
algoritma RSA adalah sebagai berikut:

68
 Tabel 4.7: Hasil perbandingan rata-rata waktu enkripsi prima 128 bit

No Algoritma Panjang karakter Rata-rata waktu enkripsi (ms)

RSA Standar 62.25

IRSA (2 prima) 74

IRSA (3 prima) 187

1 50
IRSA (4 prima) 382.25

IRSA (5 prima) 702.25

IRSA (6 prima) 1166.25

RSA Standar 132.25

IRSA (2 prima) 136.5

IRSA (3 prima) 368.25

2 100
IRSA (4 prima) 768.5

IRSA (5 prima) 1420

IRSA (6 prima) 2320.25

RSA Standar 210.5

3 IRSA (2 prima) 160 224.25

IRSA (3 prima) 616.25

69
 IRSA (4 prima) 1232.5

IRSA (5 prima) 2258.25

IRSA (6 prima) 3732.25

Kesimpulan yang dapat diambil pada tabel 4.7 yaitu waktu enkripsi algoritma
RSA standar lebih cepat dibandingkan dengan improvisasi algoritma RSA, hal ini
dikarenakan proses enkripsi algoritma RSA standar lebih sedikit dibandingkan
dengan proses enkripsi improvisasi algoritma RSA. Rata-rata waktu enkripsi
improvisasi algoritma RSA yang menggunakan 2 hingga 6 bilangan prima selalu
mengalami peningkatan tiap panjang karakter. Improvisasi algoritma RSA yang
menggunakan 6 bilangan prima memiliki rata-rata waktu enkripsi paling besar.
Perbandingan rata-rata waktu enkripsi dengan parameter panjang bit bilangan
prima 256 bit adalah sebagai berikut:

Tabel 4.8: Hasil perbandingan rata-rata waktu enkripsi prima 256 bit

No Algoritma Panjang karakter Rata-rata waktu enkripsi (ms)

RSA Standar 409.75

IRSA (2 prima) 413.75

IRSA (3 prima) 1248.25

1 50
IRSA (4 prima) 2734

IRSA (5 prima) 5097.25

IRSA (6 prima) 8544.75

RSA Standar 815.25

2 100
IRSA (2 prima) 838.5

70
 IRSA (3 prima) 2480.75

IRSA (4 prima) 5518.75

IRSA (5 prima) 10167

IRSA (6 prima) 16965

RSA Standar 1330.75

IRSA (2 prima) 1334

IRSA (3 prima) 3978.75

3 160
IRSA (4 prima) 8763.25

IRSA (5 prima) 16349.25

IRSA (6 prima) 27035

Kesimpulan yang dapat diambil pada tabel 4.8 yaitu waktu enkripsi algoritma
RSA standar lebih cepat dibandingkan dengan improvisasi algoritma RSA, hal ini
dikarenakan proses enkripsi algoritma RSA standar lebih sedikit dibandingkan
dengan proses enkripsi improvisasi algoritma RSA. Rata-rata waktu enkripsi
improvisasi algoritma RSA yang menggunakan 2 hingga 6 bilangan prima selalu
mengalami peningkatan tiap panjang karakter. Improvisasi algoritma RSA yang
menggunakan 6 bilangan prima memiliki rata-rata waktu enkripsi paling besar.

Hasil perbandingan rata-rata waktu pembangkitan kunci pada tabel 4.7

dan tabel 4.8 diatas menyimpulkan bahwa:

1. Waktu enkripsi algoritma RSA standar lebih cepat dibandingkan waktu

enkripsi improvisasi algoritma RSA. Hal ini dikarenakan komputasi untuk
melakukan enkripsi pada improvisasi algoritma RSA lebih banyak
dibandingkan dengan algoritma RSA standar.

71
2. Panjang bit bilangan prima memperngarui cepat lambatnya waktu enkripsi.
Waktu enkripsi algoritma RSA standar dan improvisasi algoritma RSA yang
menggunakan bilangan prima 128 bit lebih cepat dibandingkan dengan
menggunakan bilangan prima 256 bit.

4.2.3 Pengujian waktu dekripsi

Pengujian waktu dekripsi merupakan kelanjutan dari pengujian waktu

enkripsi sehingga teknis pengujian ini sama dengan pengujian waktu enkripsi
namun menggunakan kunci privat (N,d).

4.2.3.1 Pengujian waktu dekripsi algoritma RSA standar

Pengujian waktu dekripsi pada algoritma RSA standar dilakukan dalam

beberapa kali pengujian dengan pengaturan parameter panjang bit bilangan prima
dan panjang bit eksponen enkripsi yang berbeda. Hasil pengujian keseluruhan
dapat dilihat di lampiran 5. Hasil pengujian waktu dekripsi improvisasi algoritma
RSA dengan parameter bilangan prima 128 bit adalah sebagai berikut:

Tabel 4.9: Hasil pengujian waktu dekripsi prima 128 bit

No Panjang Default Panjang bit Panjang bit Panjang bit

karakter (ms) nilai Ф(N) - 4 nilai Ф(N) - 3 nilai Ф(N) - 2
(ms) (ms)
(ms)

1 50 78 78 78 94

2 100 171 172 156 156

3 150 250 234 296 250

72
Poin analisa yang dapat diambil dari tabel 4.9 diatas yaitu selisih waktu dekripsi
antar parameter panjang bit eksponen enkripsi (e) tidak terlalu besar. Peningkatan
panjang bit nilai e tidak menyebabkan penaikan atau penurunan waktu dekripsi
secara drastis. Hal ini menunjukkan bahwa panjang bit nilai e tidak memperngarui
waktu dekripsi.

4.2.3.2 Pengujian waktu dekripsi improvisasi algoritma RSA

Pengujian waktu dekripsi pada improvisasi algoritma RSA dilakukan

dalam beberapa kali pengujian dengan pengaturan parameter panjang bit bilangan
prima dan panjang bit eksponen enkripsi yang berbeda. Hasil pengujian
keseluruhan dapat dilihat di lampiran 6. Hasil pengujian waktu dekripsi
improvisasi algoritma RSA dengan parameter bilangan prima 128 bit adalah
sebagai berikut:

Tabel 4.10: Hasil pengujian waktu dekripsi prima 128 bit

Jumlah Panjang Default Panjang Panjang Panjang

Bilangan karakter (ms) bit nilai bit nilai bit nilai
No
prima Ф(N) - 4 Ф(N) - 3 Ф(N) - 2
(ms) (ms) (ms)

2 78 78 94 93

3 280 226 219 267

1 4 50 499 483 515 499

5 951 921 905 905

6 1544 1498 1545 1591

2 156 172 171 171

2 100
3 490 461 462 480

73
 4 968 967 998 998

5 1856 1779 1841 1826

6 2979 2964 3098 3058

2 234 265 281 265

3 763 747 729 789

3 4 150 1609 1622 1591 1576

5 2995 2886 2855 2917

6 4837 4774 4851 4836

Ada beberapa poin analisa dari hasil pengujian waktu enkripsi pada tabel 4.10
yang sebagai berikut:

1. Jumlah penggunaan bilangan prima memperngarui waktu dekripsi. Waktu

dekripsi dari improvisasi algoritma yang menggunakan 2 bilangan prima
hingga 6 bilangan prima terlihat berurutan dari nilai terkecil hingga ke nilai
terbesar. Hal ini menunjukkan semakin banyak bilangan prima yang
digunakan, waktu dekripsi akan semakin lama.

2. Ketika panjang bit eksponen enkripsi (e) ditingkatkan menjadi panjang bit
nilai Ф(N) dikurangi 2 hingga 4, waktu dekripsi sebagian besar mengalami
penurunan. Namun penurunan waktu dekripsi tersebut tidak terlalu besar.
Penurunan waktu dekripsi terjadi pada improvisasi algoritma RSA yang
menggunakan 5 dan 6 bilangan prima sedangkan pada improvisasi algoritma
RSA yang menggunakan 2 hingga 4 bilangan prima tidak dapat disumpulkan
secara pasti perubahan waktu dekripsi ketika panjang bit nilai e ditingkatkan.

4.2.3.3 Analisis waktu dekripsi

74
 Analisis waktu enkripsi dilakukan dengan membandingkan nilai rata-rata
waktu enkripsi antara algoritma RSA standar dan improvisasi algoritma RSA pada
tiap panjang karakter pesan. Nilai rata-rata waktu enkripsi diambil mulai dari
parameter panjang bit nilai e setara dengan panjang bit bilangan prima yang
dibangkitkan (default) hingga setara dengan panjang bit nilai Ф(N) dikurangi 2.
Hasil perbandingan rata-rata waktu enkripsi algoritma RSA dan improvisasi
algoritma RSA adalah sebagai berikut:

Tabel 4.11: Perbandingan rata-rata waktu dekripsi prima 128 bit

No Algoritma Panjang karakter Rata-rata waktu dekripsi (ms)

RSA Standar 82

IRSA (2 prima) 85.75

IRSA (3 prima) 248

1 50
IRSA (4 prima) 499

IRSA (5 prima) 920.5

IRSA (6 prima) 1544.5

2 RSA Standar 100 163.75

75
 IRSA (2 prima) 167.5

IRSA (3 prima) 473.25

IRSA (4 prima) 982.75

IRSA (5 prima) 1825.5

IRSA (6 prima) 3024.75

RSA Standar 257.5

IRSA (2 prima) 261.25

IRSA (3 prima) 757

3 160
IRSA (4 prima) 1598.75

IRSA (5 prima) 2913.25

IRSA (6 prima) 4824.5

Kesimpulan yang dapat diambil dari tabel 4.11 yaitu waktu dekripsi algoritma
RSA standar lebih cepat dibandingkan improvisasi algoritma RSA. Improvisasi
algoritma RSA memiliki banyak langkah untuk melakukan dekripsi seperti yang
dijelaskan pada sub bab 2.3.3 sedangkan algoritma RSA standar memiliki langkah
yang lebih sedikit untuk melakukan dekripsi seperti yang dijelaskan pada sub bab
2.3.1. Rata-rata waktu dekripsi improvisasi algoritma RSA yang menggunakan 2
hingga 6 bilangan prima selalu mengalami peningkatan. Improvisasi algoritma
RSA yang menggunakan 6 bilangan memiliki rata-rata waktu dekripsi yang paling
besar pada pengujian ini. Hasil perbandingan rata-rata waktu dekripsi dengan
parameter bilangan prima 256 bit adalah sebagai berikut:

Tabel 4.12: Perbandingan rata-rata waktu dekripsi prima 256 bit

No Algoritma Panjang karakter Rata-rata waktu enkripsi (ms)

76
 RSA Standar 508.75

IRSA (2 prima) 526.75

IRSA (3 prima) 1509.25

1 50
IRSA (4 prima) 3479.5

IRSA (5 prima) 6524.25

IRSA (6 prima) 10861.75

RSA Standar 963.5

IRSA (2 prima) 1006.25

IRSA (3 prima) 2999.5

2 100
IRSA (4 prima) 6894

IRSA (5 prima) 12854.5

IRSA (6 prima) 21727.75

RSA Standar 1567.75

IRSA (2 prima) 1649.5

IRSA (3 prima) 4820

3 160
IRSA (4 prima) 11022.75

IRSA (5 prima) 20709.5

IRSA (6 prima) 34452.75

Kesimpulan yang dapat diambil dari tabel 4.12 yaitu waktu dekripsi algoritma
RSA standar lebih cepat dibandingkan improvisasi algoritma RSA. Rata-rata
waktu dekripsi dengan parameter bilangan prima 256 bit sebagian besar lebih dari
1000 ms atau melebihi 1 detik. Rata-rata waktu dekripsi improvisasi algoritma
RSA yang menggunakan 2 hingga 6 bilangan prima selalu mengalami

77
peningkatan. Improvisasi algoritma RSA yang menggunakan 6 bilangan memiliki
rata-rata waktu dekripsi yang paling besar pada pengujian ini.

Hasil perbandingan rata-rata waktu pembangkitan kunci pada tabel 4.11

dan tabel 4.12 diatas menyimpulkan bahwa:

1. Waktu dekripsi algoritma RSA standar lebih cepat jika dibandingkan dengan
improvisasi algoritma RSA. Hal ini dikarenakan komputasi untuk melakukan
dekripsi pada improvisasi RSA lebih banyak dibandingkan komputasi untuk
melakukan dekripsi pada algoritma RSA standar.

2. Panjang bit bilangan prima memperngarui cepat lambatnya waktu dekripsi.

Waktu dekripsi algoritma RSA standar dan improvisasi algoritma RSA yang
menggunakan bilangan prima 128 bit lebih cepat dibandingkan dengan
menggunakan bilangan prima 256 bit.

4.2.4 Pengujian waktu pengiriman pesan

Pengujian waktu pengiriman pesan dilakukan dengan mengamati waktu

pengiriman pesan mulai dari client socket pengirim hingga client socket penerima.
Skenario pengujian ini sudah dijelaskan pada sub bab 1.5.4 poin ke 1.

4.2.4.1 Pengujian waktu pengiriman pesan algoritma RSA standar.

Pengujian waktu pengiriman pesan pada algoritma RSA standar

dilakukan dalam beberapa kali pengujian dengan pengaturan parameter panjang
bit bilangan prima dan panjang bit eksponen enkripsi yang berbeda. Hasil
pengujian keseluruhan dapat dilihat di lampiran 7. Waktu pengriman pesan sudah

78
mencakup waktu enkripsi dan dekripsi. Pengujian ini digunakan untuk melihat
estimasi waktu yang diperlukan algoritma untuk melakukan enkripsi dan dekripsi.
Waktu pengiriman pesan juga mencakup waktu pengiriman pesan melalui socket
TCP. Hasil pengujian waktu pengiriman pesan algoritma RSA standar dengan
parameter bilangan prima 128 bit adalah sebagai berikut:

Tabel 4.13: Hasil pengujian waktu pengiriman pesan prima 128 bit

No Panjang Default Panjang bit Panjang bit Panjang bit

karakter (ms) nilai Ф(N) - 4 nilai Ф(N) - 3 nilai Ф(N) - 2
(ms) (ms) (ms)

1 50 140 171 156 156

2 100 280 328 328 312

3 150 405 484 546 531

Poin analisa yang dapat diambil dari tabel 4.13 yaitu ketika panjang bit eksponen
enkripsi (e) ditingkatkan menjadi setara dengan panjang bit nilai Ф(N) dikurangi 2
hingga 4, waktu pengiriman pesan menjadi semakin lama. Peningkatan waktu
pengiriman tersebut menunjukkan bahwa peningkatan panjang bit nilai e tidak
berdampak terjadinya penurunan waktu dekripsi sehingga waktu pengiriman
pesan mengalami peningkatan. Waktu pengiriman pesan tercepat terjadi pada
parameter panjang bit eksponen enkripsi (e) sama dengan 128 bit (default).

4.2.4.2 Pengujian waktu pengiriman pesan improvisasi algoritma RSA

79
 Pengujian waktu pengiriman pesan pada improvisasi algoritma RSA
standar dilakukan dalam beberapa kali pengujian dengan pengaturan parameter
panjang bit bilangan prima dan panjang bit eksponen enkripsi yang berbeda. Hasil
pengujian keseluruhan dapat dilihat di lampiran 8. Waktu pengriman pesan sudah
mencakup waktu enkripsi dan dekripsi. Pengujian ini digunakan untuk melihat
estimasi waktu yang diperlukan algoritma untuk melakukan enkripsi dan dekripsi.
Waktu pengiriman pesan juga mencakup waktu pengiriman pesan melalui socket
TCP. Hasil pengujian waktu pengiriman pesan improvisasi algoritma RSA dengan
parameter bilangan prima 128 bit adalah sebagai berikut:

Tabel 4.14: Hasil pengujian waktu pengiriman pesan prima 128 bit

Jumlah Panjang Default Panjang Panjang Panjang

Bilangan karakter (ms) bit nilai bit nilai bit nilai
No
prima Ф(N) - 4 Ф(N) - 3 Ф(N) - 2
(ms) (ms) (ms)

2 125 187 188 171

3 399 458 459 512

1 4 50 639 983 1045 982

5 1170 1810 1779 1794

6 1841 2933 3027 3088

2 2 100 250 328 343 343

80
 3 680 904 912 949

4 1263 1935 1966 1981

5 2293 3542 3635 3620

6 3541 5850 6068 6022

2 405 530 530 546

3 1087 1503 1440 1570

3 4 150 2059 3135 3152 3120

5 3666 5709 5679 5740

6 5772 9453 9657 9578

Ada beberapa poin analisa dari hasil pengujian waktu enkripsi pada tabel 4.14
yang sebagai berikut:

1. Jumlah penggunaan bilangan prima memperngarui waktu pengiriman pesan.

Waktu pengiriman dari improvisasi algoritma yang menggunakan 2 bilangan
prima hingga 6 bilangan prima terlihat berurutan dari nilai terkecil hingga ke
nilai terbesar. Hal ini menunjukkan bahwa semakin banyak bilangan prima
yang digunakan, waktu pengiriman pesan akan semakin meningkat.

2. Waktu pengiriman pesan mengalami penaikkan ketika panjang bit eksponen

enkripsi (e) ditingkatkan menjadi setara dengan panjang bit nilai Ф(N)
dikurangi 2 hingga 4. Penaikkan waktu pengiriman pesan terbesar terjadi
pada improvisasi algoritma RSA yang menggunakan 5 dan 6 bilangan prima.

4.2.4.3 Analisis waktu pengiriman pesan

Analisis waktu pengiriman pesan dilakukan dengan membandingkan

nilai rata-rata waktu pengiriman pesan pada tiap panjang karakter. Hasil

81
perbandingan rata-rata waktu dekripsi algoritma RSA dan improvisasi algoritma
RSA adalah sebagai berikut:

Tabel 4.15: Perbandingan rata-rata waktu pengiriman pesan prima 128 bit

No Algoritma Panjang karakter Rata-rata waktu enkripsi (ms)

RSA Standar 155.75

IRSA (2 prima) 167.75

IRSA (3 prima) 457

1 50
IRSA (4 prima) 912.25

IRSA (5 prima) 1638.25

IRSA (6 prima) 2722.25

RSA Standar 312

IRSA (2 prima) 316

IRSA (3 prima) 861.25

2 100
IRSA (4 prima) 1786.25

IRSA (5 prima) 3272.5

IRSA (6 prima) 5370.25

RSA Standar 419.5

IRSA (2 prima) 502.75

IRSA (3 prima) 1400

3 160
IRSA (4 prima) 2866.5

IRSA (5 prima) 5198.5

IRSA (6 prima) 8615

82
Kesimpulan yang dapat diambil dari 4.15 yaitu algoritma RSA standar memiliki
waktu pengiriman yang lebih cepat dibandingkan dengan improvisasi algoritma
RSA. Hasil membuktikan bahwa algoritma RSA standar memiliki estimasi waktu
enkripsi dan dekripsi yang lebih sedikit dibandingkan dengan algoritma RSA
standar. Rata-rata waktu pengiriman pesan pada improvisasi algoritma RSA yang
menggunakan 2 hingga 6 bilangan prima selalu mengalami peningkatan.
Peningkatan jumlah penggunaan bilangan prima pada improvisasi algoritma RSA
menyebabkan meningkatnya estimasi waktu enkripsi dan waktu dekripsi. Hasil
perbandingan rata-rata waktu pengiriman pesan pada parameter bilangan prima
256 bit adalah sebagai berikut:

Tabel 4.16: Perbandingan rata-rata waktu pengiriman pesan prima 256 bit

No Algoritma Panjang karakter Rata-rata waktu enkripsi (ms)

RSA Standar 82

IRSA (2 prima) 85.75

IRSA (3 prima) 248

1 50
IRSA (4 prima) 499

IRSA (5 prima) 920.5

IRSA (6 prima) 1544.5

RSA Standar 163.75

IRSA (2 prima) 167.5

2 IRSA (3 prima) 100 473.25

IRSA (4 prima) 982.75

IRSA (5 prima) 1825.5

83
 IRSA (6 prima) 3024.75

RSA Standar 257.5

IRSA (2 prima) 261.25

IRSA (3 prima) 757

3 160
IRSA (4 prima) 1598.75

IRSA (5 prima) 2913.25

IRSA (6 prima) 4824.5

Kesimpulan yang dapat diambil dari 4.16 yaitu algoritma RSA standar memiliki
waktu pengiriman yang lebih cepat dibandingkan dengan improvisasi algoritma
RSA. Hasil membuktikan bahwa algoritma RSA standar memiliki estimasi waktu
enkripsi dan dekripsi yang lebih sedikit dibandingkan dengan algoritma RSA
standar. Improvisasi algoritma RSA yang menggunakan 6 bilangan prima
memiliki rata-rata waktu pengiriman pesan yang paling besar. Rata-rata waktu
pengiriman pesan tersebut lebih dari 1000 ms atau lebih dari 1 detik sehingga
waktu pengiriman pesan relatif lama.

Hasil perbandingan rata-rata waktu pembangkitan kunci pada tabel 4.15

dan tabel 4.16 diatas menyimpulkan bahwa:

1. Algoritma RSA standar memiliki waktu pengiriman pesan yang paling

singkat dibandingkan dengan improvisasi algoritma RSA. Hal ini dikarenakan
algoritma RSA standar memiliki waktu enkripsi dan dekripsi yang lebih kecil
dibandingkan dengan waktu enkripsi dan dekripsi pada improvisasi algoritma
RSA.

2. Panjang bit bilangan prima mempengarui cepat lambatnya waktu pengiriman

pesan. Waktu pengiriman pesan algoritma RSA standar dan improvisasi

84
 algoritma RSA yang menggunakan bilangan prima 128 bit lebih cepat
dibandingkan dengan yang menggunakan bilangan prima 256 bit.

4.2.5 Pengujian known plain text attack

Pengujian known text plain text attack dilakukan dengan menganalisis

celah keamanan algoritma terhadap metode ini. Skenario pengujian ini sudah
dijelaskan pada sub bab 1.5.4 poin ke 2.

4.2.5.1 Pengujian known plain text attack algoritma RSA standar

Pengujian known plain text attack pada algoritma RSA dilakukan dengan
memanfaatkan informasi dari server socket seperti yang sudah dijelaskan pada sub
bab 1.5.4 poin ke 2. Pengujian ini dilakukan dua kali dengan parameter bilangan
prima 128 bit dan 256 bit. Hasil pengujian ini secara keseluruhan dapat dilihat di
lampiran 9. Hasil pengujian known plain text pada algoritma RSA adalah sebagai
berikut:

Tabel 4.17: Hasil pengujian known plain text attack prima 128 bit

No Jumlah cipher text Waktu eksekusi (ms) Prosentase keberhasilan

1 50 189 ms 100 %

2 100 193 ms 100 %

3 160 205 ms 100 %

Kesimpulan yang dapat diambil dari hasil pengujian known plain text attack pada
tabel 4.17 yaitu algoritma RSA standar sangat rentan terhadap known plain text
attack. Hal ini dibuktikan dengan prosentase keberhasilan sebesar 100 persen
pada semua pengujian. Waktu eksekusi program yang ditampilkan tergolong

85
efektif sehingga metode penyerangan known plain text attack dapat meruntuhkan
keamanan algoritma RSA standar dalam waktu singkat.

4.2.5.2 Pengujian known plain text attack improvisasi algoritma RSA

Pengujian known plain text attack pada improvisasi algoritma RSA

dilakukan dengan skenario yang berbeda seperti yang dijelaskan pada sub bab
1.5.4 poin 2. Hasil pengujian known plain text attack improvisasi algoritma RSA
adalah sebagai berkut:

Tabel 4.18: Hasil pengujian known plain text attack prima 128 bit

No Jumlah Panjang bit k Prosentase Waktu eksekusi

bilangan prima keberhasilan (ms)

(2 - 8) 100 %
1 2 6832
(9 - 21) 0%

(2 - 9), 12 100 %
2 3 13916
(10 - 11), (13-21) 0%

(2 - 7) 100 %
3 4 20966
(8 - 21) 0%

(2 - 8) 100 %
4 5 31278
(9 - 21) 0%

(2 - 8) 100 %
5 6 42230
(9 - 21) 0%

Kesimpulan yang dapat diambil dari 4.18 yaitu metode known plain text attack
berhasil menemukan plain text pada interval panjang bit k 2 hingga 8 bit. Ketika
panjang bit bilangan acak k sangat kecil maka nilai k dapat ditemukan pada

86
rentang nilai 0 - 255. Apabila nilai k berhasil ditemukan maka sangatlah mudah
untuk mengetahui plain text tersembunyi dari cipher text yang diinputkan hanya
dengan kunci publik (N,e). Hal ini menyimpulkan bahwa improvisasi algoritma
rentan dari analisis known plain text attack jika panjang bit bilangan acak k untuk
enkripsi sangat kecil.

4.2.5.3 Analisis perbandingan known plain text attack

Known plain text attack digunakan untuk menemukan teks asli (plain
text) tanpa menggunakan kunci privat. Pengujian known plain text attack pada
algoritma RSA standar menunjukkan prosentase keberhasilan 100 persen,
sedangkan pada improvisasi algoritma RSA rata-rata menunjukkan prosentase
keberhasilan 100 persen pada bit nilai k 2 hingga 8 bit. Hal ini menunjukkan
bahwa algoritma RSA standar memiliki kerentanan terhadap analisis known plain
text attack yang lebih tinggi dibandingkan dengan improvisasi algoritma RSA.
Improvisasi algoritma RSA terbukti lebih aman terhadap known plain text attack
daripada algoritma RSA standar.

4.2.6 Pengujian wiener attack

Pengujian wiener attack dilakukan pada lima interval nilai d yang

berbeda yang memenuhi syarat d < N1/4. Skenario pengujian ini sudah dijelaskan
pada sub bab 1.5.4 poin 2.

4.2.6.1 Pengujian wiener attack algoritma RSA standar

Pengujian wiener attack pada algoritma RSA standar dilakukan pada

parameter bilangan prima 128 bit dan 256 bit. Hasil pengujian ini secara
keseluruhan dapat dilihat pada lampiran 11. Hasil pengujian wiener attack
algoritma RSA standar adalah sebagai berikut:

87
 Tabel 4.19: Hasil pengujian wiener attack prima 128 bit

No Interval d Berhasil Gagal Waktu eksekusi (ms)

1 ([1/2 N1/4], [5/8 N1/4]] 2995 5 1042454

2 ([5/8 N1/4], [3/4 N1/4]] 2545 455 1307624

3 ([3/4 N1/4], [13/16 N1/4]] 1827 1173 1629511

4 ([13/16 N1/4], [7/8 N1/4]] 1547 1453 1422108

5 ([7/8 N1/4], [ N1/4]] 1255 1745 1482751

Kesimpulan yang dapat diambil dari hasil pengujian wiener attack pada tabel 4.19
diatas yaitu Wiener attack tidak selalu berhasil menemukan nilai d ketika nilai d <
N1/4, hal ini dibuktikan dengan adanya pasangan kunci yang tidak berhasil
dipecahkan oleh wiener attack pada hasil diatas. Peningkatan nilai d
menyebabkan semakin sedikit nilai d yang dapat dipecahkan dari setiap invertal
sebaliknya penurunan nilai d menyebabkan semakin banyak nilai d yang dapat
ditemukan dari setiap interval. Keberhasilan wiener attack dalam memecahkan
nilai d pada algoritma RSA standar dipengarui oleh besar kecilnya nilai d pada
kunci kunci privat. Nilai d yang sangat kecil sangat mudah dipecahkan oleh
wiener attack, hal ini dibuktikan dengan jumlah kunci privat yang berhasil
dipecahkan yang semakin menurun mulai dari interval d yang pertama hingga
kelima.

4.2.6.2 Pengujian wiener attack improvisasi algoritma RSA

Pengujian wiener pada improvisasi aalgoritma RSA dilakukan pada tiap

jumlah penggunaan bilangan prima. Bilangan prima yang digunakan berukuran
128 bit dan 256 bit. Hasil pengujian ini secara keseluruhan dapat dilihat pada

88
lampiran 12. Hasil pengujian wiener attack pada improvisasi aadalah sebagai
berikut:

Tabel 4.20: Hasil pengujian wiener attack improvisasi RSA 2 prima 128 bit

No Interval d Berhasil Gagal Waktu eksekusi (ms)

1 ([1/2 N1/4], [5/8 N1/4]] 3000 0 9063596

2 ([5/8 N1/4], [3/4 N1/4]] 3000 0 6765659

3 ([3/4 N1/4], [13/16 N1/4]] 3000 0 9098604

4 ([13/16 N1/4], [7/8 N1/4]] 3000 0 3198033

5 ([7/8 N1/4], [ N1/4]] 3000 0 3391405

Kesimpulan yang dapat diambil pada hasil pengujian wiener attack pada tabel
4.20 diatas yaitu wiener attack berhasil memecahkan semua kunci privat yang
memenuhi syarat d < N1/4. Prosedur pemilihan bilangan prima yang digunakan
improvisasi algoritma RSA yang menggunakan 2 bilangan prima membuatnya
sangat rentan terhadap analisis wiener attack. Hasil ini membuktikan bahwa
keberhasilan wiener tidak hanya dipengarui oleh nilai d yang sangat kecil tetapi
juga dipengarui oleh prosedur pemilihan bilangan prima yang digunakan. Hasil
pengujian wiener attack pada improvisasi algoritma RSA yang menggunakan 3
bilangan prima dengan parameter bilangan prima 128 bit adalah sebagai berikut:

Tabel 4.21: Hasil pengujian wiener attack improvisasi RSA 3 prima 128 bit

89
 No Interval d Berhasil Gagal Waktu eksekusi (ms)

1 ([1/2 N1/4], [5/8 N1/4]] 0 3000 9063596

2 ([5/8 N1/4], [3/4 N1/4]] 0 3000 6765659

3 ([3/4 N1/4], [13/16 N1/4]] 0 3000 9098604

4 ([13/16 N1/4], [7/8 N1/4]] 0 3000 3198033

5 ([7/8 N1/4], [ N1/4]] 0 3000 3391405

Kesimpulan yang dapat diambil dari hasil pengujian wiener attack pada tabel 4.21
diatas yaitu wiener attack tidak dapat memecahkan nilai d sama sekali meskipun
nilai d < N1/4. Hasil ini membuktikan bahwa improvisasi algoritma RSA aman dari
analisis wiener attack ketika jumlah bilangan prima yang digunakan lebih dari 2.
Keberhasilan wiener attack dalam memecahkan nilai d dipengarui oleh jumlah
penggunaan bilangan prima.

4.2.6.3 Analisis perbandingan pengujian wiener attack

Wiener attack digunakan untuk menemukan nilai d pada kunci privat dari
sepasang nilai kunci publik (N,e). Ada beberapa poin yang dapat disimpulkan dari
pengujian wiener attack yang telah dilakukan pada algoritma RSA standar dan
improvisasi algoritma RSA sebagai berikut:

 Improvisasi algoritma RSA yang menggunakan lebih dari 2 bilangan prima

lebih aman terhadap analisis wiener attack daripada algoritma RSA standar
meskipun nilai d pada kunci privat kurang dari N1/4.

 Improvisasi algoritma RSA yang menggunakan 2 bilangan prima lebih rentan

terhadap analisis wiener attack dibandingkan dengan algoritma RSA standar.
Prosedur pemilihan bilangan prima yang digunakan oleh algoritma RSA
standar terbukti dapat mengurangi kerentanan dari analisis wiener attack.

90