BAB III METODELOGI PENELITIAN
4.2 Perancangan Sistem
4.2.2 Perancangan Struktur Program
Struktur program disebut juga hirarki kontrol yang mempresentasikan organisasi komponen program (modul) serta mengimplikasikan suatu hirarki kontrol. Suatu hirarki kontrol tidak mengimplikasikan aspek prosedural dari perangkat lunak, seperti urutan proses, kejadian/urutan dari keputusan, atau pengulangan operasi. Banyak notasi yang berbeda yang digunakan untuk mempresentasikan hirarki kontrol, yang paling umum adalah diagram pohon.
Seperti pada umumnya perancangan program terdiri dari judul program dan badan program. Dimana badan program ini dibagi lagi menjadi dua bagian yaitu bagian deklarasi dan bagian pernyataan (statement).
Berikut bentuk bagan struktur program yang akan diterapkan pada program kriptografi IDEA.
JUDUL PROGRAM
BLOCK PROGRAM
BAGIAN DEKLARASI FUNGSI-FUNGSI DAN VARIBEL
BAGIAN PERNYATAAN DAN PENERAPAN FUNGSI
IF …… THEN
……
END IF EKSEKUSI
PROSEDUR-PROSEDUR
Gambar 4.1 Bagan Struktur Program
Pada bagian deklasi fungis-fungsi dan variabel terdapat beberapa fungsi yang digunakan dalam program sebagai berikut:
1. FBiner2Dec (Fungsi untuk merubah nilai-nilai binary ke dalam bentuk decimal)
2. FDec2Biner (Fungsi untuk merubah nilai-nilai decimal ke dalam bentuk binary)
3. FMod (Fungsi untuk mengitung XOR sebuah nilai
4. GetIDEAKey (Fungsi untuk menghitung dan menghasilkan kunci IDEA) 5. FRotateLeftShift (Fungsi untuk merotasi nilai binary)
6. SpyRound (Fungsi untuk membulatkan perhitungan decimal) 7. Inverse (Fungsi untuk proses membalikkan nilai binary) 8. FMinus (Fungsi untuk menghitung pengurangan nilai binary) 9. Proses_Enkrip (Fungsi untuk menghitung enkripsi data) 10. Proses_Deskrip (Fungsi untuk menghitung deskripsi data) 11. Dll
Inilah sebagian fungsi-fungsi yang akan diterapkan dalam program kriptografi IDEA ini.
4.2.3 Perancangan Prosedural
Perancangan prosedural terjadi setelah perancangan data, perancangan struktur program diselesaikan. Dalam dunia nyata, spesifikasi prosedural diperlukan untuk menetapkan detail algoritma yang akan digunakan dalam suatu bahasa, seperti bahasa Indonesia. Sayangnya, ada satu masalah kecil, yakni perancangan prosedural harus menentukan detail desain, procedural tanpa ada ambiguitas. Oleh karena itu, untuk menghindari adanya ambiguitas pada perancangan prosedural, perancangan prosedural perangkat lunak Kript IDEA (International Data Encryption Algorithm) menggunakan algoritma dan flowchart.
Pada perangkat lunak Kript IDEA, terdapat dua prosedur utama, yaitu prosedur Enkripsi dan prosedur Dekripsi. Dalam procedure enkripsi ini terdapat 2 (dua) varibel yang akan diproses untuk menghasilkan sebuah chiper text (Pecahan Symbol) yaitu variabel Plain Text dan Variabel Kunci (Key)
Pada tahap awal , setelah Plain Teks dan Kunci dimasukkan maka program akan menghitung berapa banyak karakter yang dimasukkan dalam plainteks dan kunci untuk selanjutnya diciptakan sebuah blok proses perhitungan. Dengan ketentuan bahwa setiap 1 blok terdapat 8 karakter plaintext dan 16 karakter kunci.
Proses perhitungan blok ini terdapat dalam proses_kunci.
Kemudian system akan menerjemahkan karekter yang diinput tadi kedalam bentuk binary untuk masing-masing variable. Dalam hal ini untuk plain teks terdapat proses yang disebut dengan prosespbin. Dan untuk variable kunci dengan nama proseskbin.
Setelah semua kriteria untuk enkripsi ini memenuhi maka system akan melakukan sebuah prosedur yang disebut dengan Proses_Encryp. Dimana didalamnya terdapat rumus-rumus dan urutan baku dalam proses enkripsi data.
Hasil akhir dari enkripsi ini membentuk sebuah variable baru dengan nama chipper text.
Selanjutnya untuk proses deskripsi langkah-langkahnya kurang lebih sama dengan proses enkripsi, hanya membedakan pada variable inputan awal, pada deskripsi plain text sudah berubah menjadi chipper text. Symbol-simbol pada chipper text ini kemudian dirubah kedalam bentuk binary, untuk selanjutnya
dihitung (dideskrip) dengan menggunakan rumus-rumus yang telah di tanam dalam procedure proses_descript.
4.2.3.1 Proses Enkripsi Algoritma IDEA
Enkripsi adalah proses mengamankan suatu informasi dengan membuat informasi tersebut tidak dapat dibaca tanpa bantuan pengetahuan khusus. Berikut ini adalah listing program untuk proses Enkripsi dengan menggunakan Algoritma IDEA:
frmmaster.xF.Caption = "Informasi Enkripsi Data:"
'frmmaster.txtinfo.Text = ""
i = 0
For i = 1 To val(txtjlh.Text)
frmmaster.txtinfo.Text = frmmaster.txtinfo.Text & Chr(13) & "
PUTARAN " & i & " " & Chr(13)
Case 1
.TextMatrix(cRow, 1) = "(X1 * K1) mod (2^16 + 1) =(" &
msfp.TextMatrix(cRow, 1) & " * " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16 + 1)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) *
msfp.TextMatrix(cRow, 1) & " + " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) + FBiner2Dec(msfk.TextMatrix(cRow, 1))
tmpHasil = FDec2Biner(FMod(bTmp, 2 ^ 16), 16) L2 = tmpHasil
.TextMatrix(cRow, 2) = tmpHasil Case 3
.TextMatrix(cRow, 1) = "(X3 + K3) mod 2^16 =" &
msfp.TextMatrix(cRow, 1) & " + " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) +
msfp.TextMatrix(cRow, 1) & " * " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16 + 1)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) *
Case 7
Case 14
Screen.MousePointer = vbDefault Call transForm
End Sub
Berikut ini adalah proses yang terjadi pada proses Enkripsi dengan Algoritma IDEA adalah :
1. Menginput plaintekt dan kunci 2. Ubah biner
3. Lakukan proses berikut untuk sampai 8 putaran 1. Set nilai i = 1
4. Selanjutnya lakukan proses
L#7 = (L#5*K5) mod 216+1
IF i = 1, maka
4. Kemudian lakukan proses transformasi 1. Set nilai i = 1
5. Kemudian ubah hasil proses transformasi dari biner ke kode ASCII 1. Set 1 = 1
2. Lakukan perulangan sampai nilai i = 4 3. Yi = L#i
6. Kemudian di dapatkan hasil Chipertekt Y1+Y2+Y3+Y4.
4.2.3.2 Proses Dekripsi Algoritma IDEA
Dekripsi adalah proses mengembalikan suatu informasi dengan cara tertentu dan sesuai dengan algoritma enkripsi yang dipakai. Berikut ini adalah listing program untuk proses Dekripsi dengan menggunakan Algoritma IDEA:
Sub Proses_Decryp()
L1 = ""
frmmaster.xF.Caption = "Informasi Deskripsi Data:"
'frmmaster.txtinfo.Text = ""
i = 0
For i = 1 To val(txtjlh.Text)
frmmaster.txtinfo.Text = frmmaster.txtinfo.Text & Chr(13) &
"PUTARAN " & i & " " & Chr(13) With frminfopkunci.msf
& msfp.TextMatrix(cRow, 1) & " * " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16 + 1)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) *
msfp.TextMatrix(cRow, 1) & " + " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) +
msfp.TextMatrix(cRow, 1) & " + " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) + FBiner2Dec(msfk.TextMatrix(cRow, 1))
tmpHasil = FDec2Biner(FMod(bTmp, 2 ^ 16), 16) L3 = tmpHasil
.TextMatrix(cRow, 2) = tmpHasil
Case 4
.TextMatrix(cRow, 1) = "(X4 * K4) mod (2^16 + 1) =("
& msfp.TextMatrix(cRow, 1) & " * " &
msfk.TextMatrix(cRow, 1) & ") mod (2^16 + 1)"
bTmp = FBiner2Dec(msfp.TextMatrix(cRow, 1)) *
L10 = tmpHasil
Screen.MousePointer = vbDefault Call transForm
End Sub
Dimana proses yang terjadi pada proses dekripsi tidak jauh berbeda dengan proses enkripsi, berikut ini proses yang terjadi pada proses dekripsi adalah:
1. Pertama menginput chipertekt dan kunci. Dimana kunci yang di input pada proses dekripsi harus sama dengan kunci yang digunakan pada proses enkripsi.
2. Ubah biner
3. Lakukan proses berikut untuk sampai 8 putaran 1. Set nilai i = 1
2. Lakukan proses untuk nilai i = 4
Proses yang akan dilakukan cek apakah nilai i = 2 atau i = 3 Jika ya
L#i = Xi+Ki-1 mod 216.
Jika tidak
L#i = Xi*Ki-1 mod 216+1.
3. Lakukan proses XOR
L#5 = L#1 XOR L#3.
L#6 = L#2 XOR L#4.
4. Selanjutnya lakukan proses
L#7 = (L#5*K5-1) mod 216+1 L#8 = (L#6+L#7) mod 216 L#9 = (L#8*K6-1) mod 216+1 L#10 = (L#7+L#9) mod 216
5. Set untuk nilai i = 1.
6. Lakukan proses XOR sampai nilai i = 4.
Proses yang akan dilakukan
IF i = 1, maka Xi = L#1 XOR L#9
Jika tidak IF i = 2, maka Xi = L#3 XOR L#9
Jika tidak IF i = 3, maka Xi = L#2 XOR L#10 Jika tidak
Xi = L#4 XOR L#10
4. Kemudian lakukan proses transformasi 1. Set nilai i = 1
2. Lakukan proses sampai nilai i = 4 Proses yang akan dilakukan Cek apakah i = 2 atau i = 3
Jika ya
L#i = Xi+Ki-1 Mod 216 Jika tidak
L#i = Xi*Ki-1 Mod 216+1
5. Kemudian ubah hasil proses transformasi dari biner ke kode ASCII 1. Set 1 = 1
2. Lakukan perulangan sampai nilai i = 4 3. Xi = L#i
6. Kemudian di dapatkan hasil plaintext X1+X2+X3+X4.
Berikut bentuk diagram rancangan proses enkripsi dan deskripsi data menggunakan algoritma kriptografi IDEA.
Rancangan Proses Enkripsi Rancangan Proses Deskripsi
Y
Gambar 4.2 Diagram Rancangan Proses Enkripsi Dan Deskripsi Data
0
Sistem Kriptografi Algoritma IDEA User
Plainteks dan kunci
Pesan_rahasia, Pesan_asli
4.3 DIAGRAM SISTEM 4.3.1 DFD (Data Flow Diagram)
Pemodelan fungsional digambarkan dengan diagram aliran data (DFD).
DFD merupakan cara yang intuitif untuk menunjukkan bagaimana data diproses oleh sistem atau bagaimana data mengalir dalam serangkaian pemrosesan. Data ditransformasikan pada setiap langkah sebelum berlanjut ke tahapan selanjutnya.
Langkah-langkah pemrosesan atau transformasi ini merupakan fungsi program ketika, diagram aliran data digunakan untuk mendokumentasikan desain perangkat lunak.
DFD merupakan model dari sistem untuk menggambarkan pembagian sistem ke modul yang lebih kecil. Keuntungan penggunanan Data Flow Diagram adalah memudahkan pemakai yang kurang menguasai bidang komputer untuk mengerti sistem yang akan dikerjakan atau dikembangkan. Simbol DFD yang akan digunakan dalam pembahasan ini adalah simbol yang sering digunakan oleh Yourdan, De Marco dan lainnya.
Data Flow Diagram dari perangkat lunak IDEA Kripto sistem yang penulis rancang dapat dilihat pada gambar-gambar berikut ini.
4.3.2 Diagram Konteks
DFD level 0 di bawah menggambarkan sistem secara garis besar yang memperlihatkan masukan, proses, dan keluaran dari sistem yang akan dirancang.
IDEA Kripto sistem akan menghasilkan keluaran berupa pesan rahasia dan pesan asli.
Gambar 4.3 Diagram Konteks Sistem Algoritma IDEA
P.1
1. Proses 0 adalah sistem kriptografi algoritma IDEA
Dimana user menginput plainteks dan kunci untuk mengamankan data dengan menggunakan algoritma kriptografi simetris IDEA yang menghasilkan output berupa pesan rahasia, pesan asli.
4.3.3 DFD Level 1
DFD level 1 pada gambar 4.2 menggambarkan sistem secara garis besar yang memperlihatkan proses-proses yang dilakukan dalam sistem kriptografi dengan algoritma IDEA, proses ini dimulai dari proses Pembentukan Kunci, yakni proses yang dilakukan untuk mendapatkan seluruh subkunci enkripsi dan subkunci dekripsi (yang totalnya masing-masing 52 subkunci) yang diperoleh dari 8 subkunci yang dimasukkan user.
Gambar 4.4 DFD Level 1
Keterangan:
1. Proses 1 adalah pemilihan proses
Dimana di dalam proses ini, user akan memilih proses yang akan di lakukan, apakah ingin melakukan proses enkripsi atau dekripsi.
User
2. Proses 2 adalah proses enkripsi
Dimana di dalam proses ini, user menginput plaintext (pesan asli) dengan sub kunci enkripsi yang akan menghasilkan ciphertext.
3. Proses 3 adalah proses dekripsi
Dimana di dalam proses ini, user menginputkan sebuah ciphertext dari hasil proses enkripsi dengan sub kunci dekripsi yang akan menghasilkan plaintext (pesan asli).
4.3.4 DFD Level 2 Proses P.2 (Proses Enkripsi)
Proses enkripsi akan dilakukan pada setiap karakter yang telah dikonversi ke kode ASCII lalu dikonversi ke bilangan biner, karena pada algoritma IDEA digunakan bilangan biner dalam bentuk subblok, baik plainteks, kunci, maupun cipherteks. Karakter-karakter tersebut dienkripsi menggunakan 52 subblok kunci enkripsi. Untuk lebih jelasnya, proses enkripsi dapat dilihat pada gambar 4.3.
Gambar 4.5 DFD Level 2 Proses P.2
Keterangan:
1. Proses 2.1 adalah proses input file
Dimana didalam proses ini, user menginput file yang akan di enkripsi.
2. Proses 2.2 adalah konversi ke ASCII
Dimana didalam proses ini, karakter plaintext akan di konversi ke dalam kode ASCII.
3. Proses 2.3 adalah konversi ASCII ke biner (16 bit perkarakter)
Didalam proses ini, dimana kode ASCII plain akan di konversi ke dalam biner dalam hexadesimal.
4. Proses 2.4 adalah proses 64 bit menjadi 4 subblock 16 bit
Di dalam prosses ini, dimana biner plain akan mempartisi keseluruhan bit plainteks menjadi blok-blok 64 bit.
5. Proses 2.5 adalah proses enkripsi I (pertama) rounde 1-8Di dalam proses ini, dimana blok plain dan sub kunci enkripsi akan mempartisi setiap blok-blok plainteks 64 bit menjadi 4 subblok-blok16 bit.
6. Proses 2.6 adalah proses enkripsi II (dua) transformasi
Di dalam proses ini, dimana cipher1 dan sub kunci enkripsi akan melakukan proses enkripsi tahap I (di lakukan dalam 8 round).
7. Proses 2.7 adalah proses penggabungan ciphertexs
Di dalam proses ini, dimana cipher2 akan melakukan proses enkripsi II (di lakukan dalam round ke 9).
4.3.5 DFD Level 2 Proses P.3 (Proses Dekripsi)
Untuk mengembalikan cipherteks sehingga dapat dipahami, maka file yang telah dienkripsi harus didekripsi. Untuk melakukan proses dekripsi digunakan kunci yang sama, sehingga algoritma ini tergolong pada algoritma kriptografi simetris. Untuk lebih jelasnya, proses dekripsi dapat dilihat pada gambar 4.4.
User
Gambar 4.6 DFD Level 2 proses P.3
Keterangan:
1. Proses 3.1 adalah proses input file
Dimana dalam proses ini, user menginput file yang akan di lakukan dekripsi.
2. Proses 3.2 adalah proses konversi ke ASCII
Di dalam proses ini, dimana karakter cipher akan mengkonversikan karakter plaintext ke dalam kode ASCII.
3. Proses 3.3 adalah proses konversi ASCII ke biner (64 bit perkarakter) Dalam proses ini, dimana ASCII cipher akan mengkonversi kode ASCII plaintext ke dalam biner hexadesimal.
4. Proses 3.4 adalah proses partisi 64 bit jadi 4 subblok 16 bit
Dalam proses ini, dimana biner cipher akan mempartisi keseluruhan bit plaintext menjadi blok-blok 64 bit.
5. Proses 3.5 adalah proses dekripsi I (round 1-8)
Dalam proses ini, dimana block cipher dan sub kunci dekripsi akan melakukan proses dekripsi tahap I.
6. Proses 3.6 adalah proses adalah proses dekripsi tahap II (transformasi) Dalam proses ini, dimana cipher1 dan sub kunci dekripsi akan melakukan proses dekripsi tahap II.
7. Proses 3.7 adalah proses gabung keseluruhan blok bit
Dalam proses ini, dimana cipher2 akan menggabungkan setiap 16 bit subblok plaintext menjadi blok 64 bit.
8. Proses 3.8 adalah proses konversi biner ke ASCII
Dalam proses ini, dimana biner plain akan mengkonversi setiap bit hexaplaintext menjadi kode ASCII nya.
9. Proses 3.9 adalah proses konversi ke ASCII
Dalam proses ini, dimana ASCII plain akan di konversi setiap kode ASCII menjadi karakter-karakternya.
10. Proses 3.10 adalah proses gabung plaintext
Dalam proses ini, user akan menggabungkan seluruh karakter-karakter plain menjadi karakter plaintext.
4.4 IMPLEMENTASI
Tahap implementasi dilakukan setelah perancangan sistem kriptografi IDEA selesai dilakukan. Dalam implementasi akan ditampilkan bentuk dari program yang dirancang. Ada pun program yang dimaksud terdiri atas beberapa tampilan halaman, yaitu: halaman utama, form enkripsi, dan form dekripsi.
4.4.1 Implementasi Sistem
Proses penyelesaian kriptografi Algoritma IDEA ini dapat di bagi menjadi dua tahapan proses yaitu proses enkripsi dan proses dekripsi.
4.4.1.1 Proses Enkripsi
Dimana dalam proses algoritma IDEA ini memiliki 8 iterasi (putaran) di tambah satu putaran transformasi output. Untuk lebih jelasnya tentang bagaimana proses kerja enkripsi algoritma IDEA ini dapat di lihat pada contoh berikut:
Misalkan kita akan mengenkripsi pesan, dimana pesan plaintext dan kunci.
Kunci : KRIPTOGRAFI IDEA Plaintext : ABDHANAN
Berikut ini adalah proses enkripsi dari algoritma IDEA.
PROSES UNTUK BLOCK 1 PUTARAN 1
L#1 (X1 * K1) mod (2^16 + 1)
= (0100000101001100 * 0100101101010010) mod (2^16 + 1)
= 0001101100100010 L#2 (X2 + K2) mod 2^16
= 0101000001001001 + 0100100101010000) mod (2^16)
= 1001100110011001 L#3 (X3 + K3) mod 2^16
= 0100000101001110 + 0101010001001111) mod (2^16)
= 1001010110011101 L#4 (X4 * K4) mod (2^16 + 1)
= (0101010001001111 * 0100011101010010) mod (2^16 + 1)
= 1101001011010010 L#5 L#1 XOR L#3
= 0001101100100010 XOR 1001010110011101 = 1000111010111111 L#6 L#2 XOR L#4
= 1001100110011001 XOR 1101001011010010 = 0100101101001011 L#7 (L#5 * K5) mod (2^16 + 1)
= 1000111010111111 * 0100000101000110 mod (2^16 + 1)
= 0110001011010101 L#8 (L#6 + L#7) mod 2^16
= 0100101101001011 + 0110001011010101 mod 2^16
= 1010111000100000 L#9 (L#8 * K6) mod (2^16 + 1)
= 1010111000100000 * 0100100100100000 = 1011001001000100 L#10 (L#7 + L#9) mod 2^16
= 0110001011010101 + 1011001001000100 mod 2^16
= 0001010100011001 L#11 L#1 XOR L#9
= 0001101100100010 XOR 1011001001000100 = 1010100101100110 L#12 L#3 XOR L#9
= 1001010110011101 XOR 1011001001000100 = 0010011111011001 L#13 L#2 XOR L#10
= 1001100110011001 XOR 0001010100011001 = 1000110010000000
L#14 L#4 XOR L#10
= 1101001011010010 XOR 0001010100011001 = 1100011111001011 PUTARAN 2
L#1 (X1 * K1) mod (2^16 + 1)
= (1010100101100110 * 0100100101000100) mod (2^16 + 1)
= 1110010010011110 L#2 (X2 + K2) mod 2^16
= 0010011111011001 + 0100010101000001) mod (2^16)
= 0110110100011010 L#3 (X3 + K3) mod 2^16
= 1000110010000000 + 1010000010101000) mod (2^16)
= 0010110100101000 L#4 (X4 * K4) mod (2^16 + 1)
= (1100011111001011 * 1001111010001110) mod (2^16 + 1)
= 1010000011011101 L#5 L#1 XOR L#3
= 1110010010011110 XOR 0010110100101000 = 1100100110110110 L#6 L#2 XOR L#4
= 0110110100011010 XOR 1010000011011101 = 1100110111000111 L#7 (L#5 * K5) mod (2^16 + 1)
= 1100100110110110 * 1010010010000010 mod (2^16 + 1)
= 1000010011001110 L#8 (L#6 + L#7) mod 2^16
= 1100110111000111 + 1000010011001110 mod 2^16
= 0101001010010101 L#9 (L#8 * K6) mod (2^16 + 1)
= 0101001010010101 * 1000110010010010 = 0110011110100010 L#10 (L#7 + L#9) mod 2^16
= 1000010011001110 + 0110011110100010 mod 2^16
= 1110110001110000 L#11 L#1 XOR L#9
= 1110010010011110 XOR 0110011110100010 = 1000001100111100 L#12 L#3 XOR L#9
= 0010110100101000 XOR 0110011110100010 = 0100101010001010 L#13 L#2 XOR L#10
= 0110110100011010 XOR 1110110001110000 = 1000000101101010 L#14 L#4 XOR L#10
= 1010000011011101 XOR 1110110001110000 = 0100110010101101
PUTARAN 3
L#1 (X1 * K1) mod (2^16 + 1)
= (1000001100111100 * 0100000010010010) mod (2^16 + 1)
= 1011011100011111
L#2 (X2 + K2) mod 2^16
= 0100101010001010 + 1000100010001010) mod (2^16)
= 1101001100010100 L#3 (X3 + K3) mod 2^16
= 1000000101101010 + 1000001010010110) mod (2^16)
= 0000010000000000 L#4 (X4 * K4) mod (2^16 + 1)
= (0100110010101101 * 1010010010010010) mod (2^16 + 1)
= 0101110101100000 L#5 L#1 XOR L#3
= 1011011100011111 XOR 0000010000000000 = 1011001100011111 L#6 L#2 XOR L#4
= 1101001100010100 XOR 0101110101100000 = 1000111001110100 L#7 (L#5 * K5) mod (2^16 + 1)
= 1011001100011111 * 0001110101001001 mod (2^16 + 1)
= 1000001001011010 L#8 (L#6 + L#7) mod 2^16
= 1000111001110100 + 1000001001011010 mod 2^16
= 0001000011001110 L#9 (L#8 * K6) mod (2^16 + 1)
= 0001000011001110 * 0000010100011001 = 1010100111001001 L#10 (L#7 + L#9) mod 2^16
= 1000001001011010 + 1010100111001001 mod 2^16
= 0010110000100011 L#11 L#1 XOR L#9
= 1011011100011111 XOR 1010100111001001 = 0001111011010110 L#12 L#3 XOR L#9
= 0000010000000000 XOR 1010100111001001 = 1010110111001001 L#13 L#2 XOR L#10
= 1101001100010100 XOR 0010110000100011 = 1111111100110111 L#14 L#4 XOR L#10
= 0101110101100000 XOR 0010110000100011 = 0111000101000011 PUTARAN 4
L#1 (X1 * K1) mod (2^16 + 1)
= (0001111011010110 * 0010010010000001) mod (2^16 + 1)
= 1001110101110001
L#2 (X2 + K2) mod 2^16
= 1010110111001001 + 0010010100010001) mod (2^16)
= 1101001011011010
L#3 (X3 + K3) mod 2^16
= 1111111100110111 + 0001010100000101) mod (2^16)
= 0001010000111100 L#4 (X4 * K4) mod (2^16 + 1)
= (0111000101000011 * 0010110101001001) mod (2^16 + 1)
= 1111111100010011 L#5 L#1 XOR L#3
= 1001110101110001 XOR 0001010000111100 = 1000100101001101 L#6 L#2 XOR L#4
= 1101001011011010 XOR 1111111100010011 = 0010110111001001 L#7 (L#5 * K5) mod (2^16 + 1)
= 1000100101001101 * 0010010101000001 mod (2^16 + 1)
= 1110100110010011 L#8 (L#6 + L#7) mod 2^16
= 0010110111001001 + 1110100110010011 mod 2^16
= 0001011101011100 L#9 (L#8 * K6) mod (2^16 + 1)
= 0001011101011100 * 0101000100111101 = 1010010110000011 L#10 (L#7 + L#9) mod 2^16
= 1110100110010011 + 1010010110000011 mod 2^16
= 1000111100010110 L#11 L#1 XOR L#9
= 1001110101110001 XOR 1010010110000011 = 0011100011110010 L#12 L#3 XOR L#9
= 0001010000111100 XOR 1010010110000011 = 1011000110111111 L#13 L#2 XOR L#10
= 1101001011011010 XOR 1000111100010110 = 0101110111001100 L#14 L#4 XOR L#10
= 1111111100010011 XOR 1000111100010110 = 0111000000000101 PUTARAN 5
L#1 (X1 * K1) mod (2^16 + 1)
= (0011100011110010 * 0011001001001001) mod (2^16 + 1)
= 0111010111010011 L#2 (X2 + K2) mod 2^16
= 1011000110111111 + 0000001001001010) mod (2^16)
= 1011010000001001
L#3 (X3 + K3) mod 2^16
= 0101110111001100 + 0010001000101010) mod (2^16)
= 0111111111110110 L#4 (X4 * K4) mod (2^16 + 1)
= (0111000000000101 * 0000101001011010) mod (2^16 + 1)
= 1000111100111011 L#5 L#1 XOR L#3
= 0111010111010011 XOR 0111111111110110 = 0000101000100101 L#6 L#2 XOR L#4
= 1011010000001001 XOR 1000111100111011 = 0011101100110010 L#7 (L#5 * K5) mod (2^16 + 1)
= 0000101000100101 * 1001001001001010 mod (2^16 + 1)
= 0000001011100110 L#8 (L#6 + L#7) mod 2^16
= 0011101100110010 + 0000001011100110 mod 2^16
= 0011111000011000 L#9 (L#8 * K6) mod (2^16 + 1)
= 0011111000011000 * 1000001010100010 = 0101101110000001 L#10 (L#7 + L#9) mod 2^16
= 0000001011100110 + 0101101110000001 mod 2^16
= 0101111001100111 L#11 L#1 XOR L#9
= 0111010111010011 XOR 0101101110000001 = 0010111001010010 L#12 L#3 XOR L#9
= 0111111111110110 XOR 0101101110000001 = 0010010001110111 L#13 L#2 XOR L#10
= 1011010000001001 XOR 0101111001100111 = 1110101001101110 L#14 L#4 XOR L#10
= 1000111100111011 XOR 0101111001100111 = 1101000101011100 PUTARAN 6
L#1 (X1 * K1) mod (2^16 + 1)
= (0010111001010010 * 0111101000111010) mod (2^16 + 1)
= 0111110001110111 L#2 (X2 + K2) mod 2^16
= 0010010001110111 + 1001001000001010) mod (2^16)
= 1011011010000001 L#3 (X3 + K3) mod 2^16
= 1110101001101110 + 1001010001000100) mod (2^16)
= 0111111010110010
L#4 (X4 * K4) mod (2^16 + 1)
= (1101000101011100 * 0101010000010100) mod (2^16 + 1)
= 0100011001101110 L#5 L#1 XOR L#3
= 0111110001110111 XOR 0111111010110010 = 0000001011000101 L#6 L#2 XOR L#4
= 1011011010000001 XOR 0100011001101110 = 1111000011101111 L#7 (L#5 * K5) mod (2^16 + 1)
= 0000001011000101 * 1011010100100100 mod (2^16 + 1)
= 1010101010111111 L#8 (L#6 + L#7) mod 2^16
= 1111000011101111 + 1010101010111111 mod 2^16
= 1001101110101110 L#9 (L#8 * K6) mod (2^16 + 1)
= 1001101110101110 * 1001010100000101 = 1111010111001000 L#10 (L#7 + L#9) mod 2^16
= 1010101010111111 + 1111010111001000 mod 2^16
= 1010000010000111 L#11 L#1 XOR L#9
= 0111110001110111 XOR 1111010111001000 = 1000100110111111 L#12 L#3 XOR L#9
= 0111111010110010 XOR 1111010111001000 = 1000101101111010 L#13 L#2 XOR L#10
= 1011011010000001 XOR 1010000010000111 = 0001011000000110 L#14 L#4 XOR L#10
= 0100011001101110 XOR 1010000010000111 = 1110011011101001 PUTARAN 7
L#1 (X1 * K1) mod (2^16 + 1)
= (1000100110111111 * 0100010011110100) mod (2^16 + 1)
= 1110000011110011 L#2 (X2 + K2) mod 2^16
= 1000101101111010 + 0111010100100100) mod (2^16)
= 0000000010011110 L#3 (X3 + K3) mod 2^16
= 0001011000000110 + 0001010001100100) mod (2^16)
= 0010101001101010 L#4 (X4 * K4) mod (2^16 + 1)
= (1110011011101001 * 1001001000000100) mod (2^16 + 1)
= 1111100111110001
L#5 L#1 XOR L#3
= 1110000011110011 XOR 0010101001101010 = 1100101010011001 L#6 L#2 XOR L#4
= 0000000010011110 XOR 1111100111110001 = 1111100101101111
L#7 (L#5 * K5) mod (2^16 + 1)
= 1100101010011001 * 0010100101101010 mod (2^16 + 1)
= 0100001110010100 L#8 (L#6 + L#7) mod 2^16
= 1111100101101111 + 0100001110010100 mod 2^16
= 0011110100000011 L#9 (L#8 * K6) mod (2^16 + 1)
= 0011110100000011 * 0100100100101010 = 1100110000001111 L#10 (L#7 + L#9) mod 2^16
= 0100001110010100 + 1100110000001111 mod 2^16
= 0000111110100011 L#11 L#1 XOR L#9
= 1110000011110011 XOR 1100110000001111 = 0010110011111100 L#12 L#3 XOR L#9
= 0010101001101010 XOR 1100110000001111 = 1110011001100101 L#13 L#2 XOR L#10
= 0000000010011110 XOR 0000111110100011 = 0000111100111101 L#14 L#4 XOR L#10
= 1111100111110001 XOR 0000111110100011 = 1111011001010010 PUTARAN 8
L#1 (X1 * K1) mod (2^16 + 1)
= (0010110011111100 * 0000101010001001) mod (2^16 + 1)
= 1110100100000011 L#2 (X2 + K2) mod 2^16
= 1110011001100101 + 1110100011101010) mod (2^16)
= 1100111101001111 L#3 (X3 + K3) mod 2^16
= 0000111100111101 + 0100100000101000) mod (2^16)
= 0101011101100101 L#4 (X4 * K4) mod (2^16 + 1)
= (1111011001010010 * 1100100100100100) mod (2^16 + 1)
= 0100010000000000 L#5 L#1 XOR L#3
= 1110100100000011 XOR 0101011101100101 = 1011111001100110 L#6 L#2 XOR L#4
= 1100111101001111 XOR 0100010000000000 = 1000101101001111
L#7 (L#5 * K5) mod (2^16 + 1)
= 1011111001100110 * 0000100100101000 mod (2^16 + 1)
= 0100111100100001 L#8 (L#6 + L#7) mod 2^16
= 1000101101001111 + 0100111100100001mod 2^16
= 1101101001110000 L#9 (L#8 * K6) mod (2^16 + 1)
= 1101101001110000 * 1000100010101000 = 0110010011100110 L#10 (L#7 + L#9) mod 2^16
= 0100111100100001 + 0110010011100110mod 2^16
= 1011010000000111 L#11 L#1 XOR L#9
= 1110100100000011 XOR 0110010011100110 = 1000110111100101 L#12 L#3 XOR L#9
= 0101011101100101 XOR 0110010011100110 = 0011001110000011 L#13 L#2 XOR L#10
= 1100111101001111 XOR 1011010000000111 = 0111101101001000 L#14 L#4 XOR L#10
= 0100010000000000 XOR 1011010000000111 = 1111000000000111 TRANSFORMASI OUTPUT 1
L#1 (X1 * K1) mod (2^16 + 1)
= 1000110111100101 * 0101010000010101 mod (2^16 + 1)
= 1001100100101111 = ™/
L#2 (X2 + K2) mod 2^16
= 0111101101001000 + 0001001111010001 Mod 2 ^ 16
= 1000111100011001 = •_
L#3 (X3 + K3) mod 2^16
= 0011001110000011 + 1101010010010000 mod 2^16
= 0000100000010011 = __
L#4 (X4 * K4) mod (2^16 + 1)
= 1111000000000111 * 0101000110010010 mod (2^16 + 1)
= 1100111010000100 = ΄
Setelah 8 putaran dan di tambah satu putaran transfortasi proses enkripsi selesai, maka di dapatkan Chiper Text ™/•hŠm?çǺI¦
4.4.1.1.1 Flow Chat Enkripsi Data
Berikut ditampilan flowchat proses Enkripsi data dimana pesan plaintext dan kunci.
Kunci : KRIPTOGRAFI IDEA Plaintext : ABDHANAN
User
Plain Teks : ABDHANAN Dan Kunci : KRIPTOGRAFI IDEA
Menguji variabel Inputan (Var. Lengkap)
Pembentukan Block Proses (Jlh. Block=1) Y
T
Proses Ke n
Proses Ke n proses_ kunci
prosespbin proseskbin
Proses_ Encryp
Menghasilkan chipertext
=
™/ hŠm?çǺI
selesai
Beberapa Contoh Enkripsi Data
Berikut diperlihatkan beberapa contoh Enkripsi yang dihasilkan menggunakan program aplikasi ini dalam Teori Enkripsi IDEA.
No. Plain Text Kata Kunci Ciphertext
1 ubudiyah mahasiswadsabang ä Ï
2 kuliahIT programmerdrsabang 4÷ýÈ@Æ •
3 kuncikey passworddankunci Ó_ÒÓàc-C
4 plaintex crystaletekeydat úÝö$r-¾
5 proteksi dataterkuncibaru µu¿ð?«ï
4.4.1.2 Proses Deskripsi
Proses dekripsi merupakan proses kebalikan dari proses enkripsi.
Proses dekripsi menggunakan kunci yang sama dengan proses enkripsi. Sebagai contoh, jika ingin di dekripsikan kembali dari hasil enkripsi di atas dengan menggunakan kunci yang sama, maka hasilnya sebagai berikut.
PROSES UNTUK BLOCK 1 PUTARAN 1
L#1 (X1 * K1) mod (2^16 + 1)
= (1001100100101111 * 1000000100010001) mod (2^16 + 1)
= 1000110111100101 L#2 (X2 + K2) mod 2^16
= 1000111100011001 + 1110110000101111) mod (2^16)
= 0111101101001000 L#3 (X3 + K3) mod 2^16
= 0000100000010011 + 0010101101110000) mod (2^16)
= 0011001110000011 L#4 (X4 * K4) mod (2^16 + 1)
= (1100111010000100 * 1110100111000111) mod (2^16 + 1)
= 1111000000000111 L#5 L#1 XOR L#3
= 1000110111100101 XOR 0011001110000011 = 1011111001100110 L#6 L#2 XOR L#4
= 0111101101001000 XOR 1111000000000111 = 1000101101001111 L#7 (L#5 * K5) mod (2^16 + 1)
= 1011111001100110 * 0000100100101000 mod (2^16 + 1)
= 0100111100100001 L#8 (L#6 + L#7) mod 2^16
= 1000101101001111 + 0100111100100001 mod 2^16
= 1101101001110000 L#9 (L#8 * K6) mod (2^16 + 1)
= 1101101001110000 * 1000100010101000 = 0110010011100110 L#10 (L#7 + L#9) mod 2^16
= 0100111100100001 + 0110010011100110 mod 2^16
= 1011010000000111 L#11 L#1 XOR L#9
= 1000110111100101 XOR 0110010011100110 = 1110100100000011 L#12 L#3 XOR L#9
= 0011001110000011 XOR 0110010011100110 = 0101011101100101 L#13 L#2 XOR L#10
= 0111101101001000 XOR 1011010000000111 = 1100111101001111 L#14 L#4 XOR L#10
= 1111000000000111 XOR 1011010000000111 = 0100010000000000 PUTARAN 2
L#1 (X1 * K1) mod (2^16 + 1)
= (1110100100000011 * 0000000011110011) mod (2^16 + 1)
= 0010110011111100 L#2 (X2 + K2) mod 2^16
= 0101011101100101 + 1011011111011000) mod (2^16)
= 0000111100111101 L#3 (X3 + K3) mod 2^16
= 1100111101001111 + 0001011100010110) mod (2^16)
= 1110011001100101 L#4 (X4 * K4) mod (2^16 + 1)
= (0100010000000000 * 1100101000011011) mod (2^16 + 1)
= 1111011001010010 L#5 L#1 XOR L#3
= 0010110011111100 XOR 1110011001100101 = 1100101010011001 L#6 L#2 XOR L#4
= 0000111100111101 XOR 1111011001010010 = 1111100101101111 L#7 (L#5 * K5) mod (2^16 + 1)
= 1100101010011001 * 0010100101101010 mod (2^16 + 1)
= 0100001110010100 L#8 (L#6 + L#7) mod 2^16
= 1111100101101111 + 0100001110010100 mod 2^16
= 0011110100000011 L#9 (L#8 * K6) mod (2^16 + 1)
= 0011110100000011 * 0100100100101010 = 1100110000001111
L#10 (L#7 + L#9) mod 2^16
= 0100001110010100 + 1100110000001111 mod 2^16
= 0000111110100011 L#11 L#1 XOR L#9
= 0010110011111100 XOR 1100110000001111 = 1110000011110011 L#12 L#3 XOR L#9
= 1110011001100101 XOR 1100110000001111 = 0010101001101010 L#13 L#2 XOR L#10
= 0000111100111101 XOR 0000111110100011 = 0000000010011110 L#14 L#4 XOR L#10
= 1111011001010010 XOR 0000111110100011 = 1111100111110001 PUTARAN 3
L#1 (X1 * K1) mod (2^16 + 1)
= (1110000011110011 * 0111100010110101) mod (2^16 + 1)
= 1000100110111111 L#2 (X2 + K2) mod 2^16
= 0010101001101010 + 1110101110011100) mod (2^16)
= 0001011000000110 L#3 (X3 + K3) mod 2^16
= 0000000010011110 + 1000101011011100) mod (2^16)
= 1000101101111010 L#4 (X4 * K4) mod (2^16 + 1)
= (1111100111110001 * 0111110101100001) mod (2^16 + 1)
= 1110011011101001 L#5 L#1 XOR L#3
= 1000100110111111 XOR 1000101101111010 = 0000001011000101 L#6 L#2 XOR L#4
= 0001011000000110 XOR 1110011011101001 = 1111000011101111 L#7 (L#5 * K5) mod (2^16 + 1)
= 0000001011000101 * 1011010100100100 mod (2^16 + 1)
= 1010101010111111 L#8 (L#6 + L#7) mod 2^16
= 1111000011101111 + 1010101010111111 mod 2^16
= 1001101110101110 L#9 (L#8 * K6) mod (2^16 + 1)
= 1001101110101110 * 1001010100000101 = 1111010111001000 L#10 (L#7 + L#9) mod 2^16
= 1010101010111111 + 1111010111001000 mod 2^16
= 1010000010000111 L#11 L#1 XOR L#9
= 1000100110111111 XOR 1111010111001000 = 0111110001110111
L#12 L#3 XOR L#9
= 1000101101111010 XOR 1111010111001000 = 0111111010110010 L#13 L#2 XOR L#10
= 0001011000000110 XOR 1010000010000111 = 1011011010000001 L#14 L#4 XOR L#10
= 1110011011101001 XOR 1010000010000111 = 0100011001101110 PUTARAN 4
L#1 (X1 * K1) mod (2^16 + 1)
= (0111110001110111 * 0111010100100011) mod (2^16 + 1)
= 0010111001010010 L#2 (X2 + K2) mod 2^16
= 0111111010110010 + 0110101110111100) mod (2^16)
= 1110101001101110
L#3 (X3 + K3) mod 2^16
= 1011011010000001 + 0110110111110110) mod (2^16)
= 0010010001110111 L#4 (X4 * K4) mod (2^16 + 1)
= (0100011001101110 * 0100101000000100) mod (2^16 + 1)
= 1101000101011100 L#5 L#1 XOR L#3
= 0010111001010010 XOR 0010010001110111 = 0000101000100101 L#6 L#2 XOR L#4
= 1110101001101110 XOR 1101000101011100 = 0011101100110010 L#7 (L#5 * K5) mod (2^16 + 1)
= 0000101000100101 * 1001001001001010 mod (2^16 + 1)
= 0000001011100110 L#8 (L#6 + L#7) mod 2^16
= 0011101100110010 + 0000001011100110 mod 2^16
= 0011111000011000 L#9 (L#8 * K6) mod (2^16 + 1)
= 0011111000011000 * 1000001010100010 = 0101101110000001 L#10 (L#7 + L#9) mod 2^16
= 0000001011100110 + 0101101110000001 mod 2^16
= 0101111001100111 L#11 L#1 XOR L#9
= 0010111001010010 XOR 0101101110000001 = 0111010111010011 L#12 L#3 XOR L#9
= 0010010001110111 XOR 0101101110000001 = 0111111111110110 L#13 L#2 XOR L#10
= 1110101001101110 XOR 0101111001100111 = 1011010000001001 L#14 L#4 XOR L#10
= 1101000101011100 XOR 0101111001100111 = 1000111100111011 PUTARAN 5
L#1 (X1 * K1) mod (2^16 + 1)
= (0111010111010011 * 0010100001101001) mod (2^16 + 1)
= 0011100011110010 L#2 (X2 + K2) mod 2^16
= 0111111111110110 + 1101110111010110) mod (2^16)
= 0101110111001100 L#3 (X3 + K3) mod 2^16
= 1011010000001001 + 1111110110110110) mod (2^16)
= 1011000110111111
L#4 (X4 * K4) mod (2^16 + 1)
= (1000111100111011 * 1110101001110110) mod (2^16 + 1)
= 0111000000000101 L#5 L#1 XOR L#3
= 0011100011110010 XOR 1011000110111111 = 1000100101001101 L#6 L#2 XOR L#4
= 0101110111001100 XOR 0111000000000101 = 0010110111001001 L#7 (L#5 * K5) mod (2^16 + 1)
= 1000100101001101 * 0010010101000001 mod (2^16 + 1)
= 1110100110010011 L#8 (L#6 + L#7) mod 2^16
= 0010110111001001 + 1110100110010011 mod 2^16
= 0001011101011100 L#9 (L#8 * K6) mod (2^16 + 1)
= 0001011101011100 * 0101000100111101 = 1010010110000011 L#10 (L#7 + L#9) mod 2^16
= 1110100110010011 + 1010010110000011 mod 2^16
= 1000111100010110 L#11 L#1 XOR L#9
= 0011100011110010 XOR 1010010110000011 = 1001110101110001 L#12 L#3 XOR L#9
= 1011000110111111 XOR 1010010110000011 = 0001010000111100 L#13 L#2 XOR L#10
= 0101110111001100 XOR 1000111100010110 = 1101001011011010 L#14 L#4 XOR L#10
= 0111000000000101 XOR 1000111100010110 = 1111111100010011
PUTARAN 6
L#1 (X1 * K1) mod (2^16 + 1)
= (1001110101110001 * 1111010110000011) mod (2^16 + 1)
= 0001111011010110 L#2 (X2 + K2) mod 2^16
= 0001010000111100 + 1110101011111011) mod (2^16)
= 1111111100110111 L#3 (X3 + K3) mod 2^16
= 1101001011011010 + 1101101011101111) mod (2^16)
= 1010110111001001 L#4 (X4 * K4) mod (2^16 + 1)
= (1111111100010011 * 0000010011100111) mod (2^16 + 1)
= 0111000101000011
L#5 L#1 XOR L#3
= 0001111011010110 XOR 1010110111001001 = 1011001100011111 L#6 L#2 XOR L#4
= 1111111100110111 XOR 0111000101000011 = 1000111001110100 L#7 (L#5 * K5) mod (2^16 + 1)
= 1011001100011111 * 0001110101001001 mod (2^16 + 1)
= 1000001001011010 L#8 (L#6 + L#7) mod 2^16
= 1000111001110100 + 1000001001011010 mod 2^16
= 0001000011001110 L#9 (L#8 * K6) mod (2^16 + 1)
= 0001000011001110 * 0000010100011001 = 1010100111001001 L#10 (L#7 + L#9) mod 2^16
= 1000001001011010 + 1010100111001001 mod 2^16
= 0010110000100011 L#11 L#1 XOR L#9
= 0001111011010110 XOR 1010100111001001 = 1011011100011111 L#12 L#3 XOR L#9
= 1010110111001001 XOR 1010100111001001 = 0000010000000000 L#13 L#2 XOR L#10
= 1111111100110111 XOR 0010110000100011 = 1101001100010100 L#14 L#4 XOR L#10
= 0111000101000011 XOR 0010110000100011 = 0101110101100000 PUTARAN 7
L#1 (X1 * K1) mod (2^16 + 1)
= (1011011100011111 * 1011111000100011) mod (2^16 + 1)
= 1000001100111100
L#2 (X2 + K2) mod 2^16
= 0000010000000000 + 0111110101101010) mod (2^16)
= 1000000101101010 L#3 (X3 + K3) mod 2^16
= 1101001100010100 + 0111011101110110) mod (2^16)
= 0100101010001010 L#4 (X4 * K4) mod (2^16 + 1)
= (0101110101100000 * 1100010011101100) mod (2^16 + 1)
= 0100110010101101 L#5 L#1 XOR L#3
= 1000001100111100 XOR 0100101010001010 = 1100100110110110 L#6 L#2 XOR L#4
= 1000000101101010 XOR 0100110010101101 = 1100110111000111 L#7 (L#5 * K5) mod (2^16 + 1)
= 1100100110110110 * 1010010010000010 mod (2^16 + 1)
= 1000010011001110 L#8 (L#6 + L#7) mod 2^16
= 1100110111000111 + 1000010011001110 mod 2^16
= 0101001010010101 L#9 (L#8 * K6) mod (2^16 + 1)
= 0101001010010101 * 1000110010010010 = 0110011110100010 L#10 (L#7 + L#9) mod 2^16
= 1000010011001110 + 0110011110100010 mod 2^16
= 1110110001110000 L#11 L#1 XOR L#9
= 1000001100111100 XOR 0110011110100010 = 1110010010011110 L#12 L#3 XOR L#9
= 0100101010001010 XOR 0110011110100010 = 0010110100101000 L#13 L#2 XOR L#10
= 1000000101101010 XOR 1110110001110000 = 0110110100011010 L#14 L#4 XOR L#10
= 0100110010101101 XOR 1110110001110000 = 1010000011011101 PUTARAN 8
L#1 (X1 * K1) mod (2^16 + 1)
= (1110010010011110 * 0001111110110101) mod (2^16 + 1)
= 1010100101100110 L#2 (X2 + K2) mod 2^16
= 0010110100101000 + 0101111101011000) mod (2^16)
= 1000110010000000 L#3 (X3 + K3) mod 2^16
= 0110110100011010 + 1011101010111111) mod (2^16)
= 0010011111011001 L#4 (X4 * K4) mod (2^16 + 1)
= (1010000011011101 * 0000001010000001) mod (2^16 + 1)
= 1100011111001011 L#5 L#1 XOR L#3
= 1010100101100110 XOR 0010011111011001 = 1000111010111111 L#6 L#2 XOR L#4
= 1000110010000000 XOR 1100011111001011 = 0100101101001011 L#7 (L#5 * K5) mod (2^16 + 1)
= 1000111010111111 * 0100000101000110 mod (2^16 + 1)
= 0110001011010101
L#8 (L#6 + L#7) mod 2^16
= 0100101101001011 + 0110001011010101 mod 2^16
= 1010111000100000 L#9 (L#8 * K6) mod (2^16 + 1)
= 1010111000100000 * 0100100100100000 = 1011001001000100 L#10 (L#7 + L#9) mod 2^16
= 0110001011010101 + 1011001001000100 mod 2^16
= 0001010100011001 L#11 L#1 XOR L#9
= 1010100101100110 XOR 1011001001000100 = 0001101100100010 L#12 L#3 XOR L#9
= 0010011111011001 XOR 1011001001000100 = 1001010110011101 L#13 L#2 XOR L#10
= 1000110010000000 XOR 0001010100011001 = 1001100110011001 L#14 L#4 XOR L#10
= 1100011111001011 XOR 0001010100011001 = 1101001011010010 TRANSFORMASI OUTPUT
L#1 (X1 * K1) mod (2^16 + 1)
= 0001101100100010 * 0111010101101111 mod (2^16 + 1)
= 0100000101001100 = AB L#2 (X2 + K2) mod 2^16
= 1001100110011001 + 1011011010110000 Mod 2 ^ 16
= 0101000001001001 = DH L#3 (X3 + K3) mod 2^16
= 1001010110011101 + 1010101110110001 mod 2^16
= 0100000101001110 = AN L#4 (X4 * K4) mod (2^16 + 1)
= 1101001011010010 * 1001111100011010 mod (2^16 + 1)
= 0100000101001110 = AN
Hasil proses dekripsi di atas adalah:
= 0100000101001100 = AB
= 0101000001001001 = DH
= 0100000101001110 = AN
= 0100000101001110 = AN
Setelah proses dekripsi di atas selesai maka di peroleh plaintext awal adalah ABDHANAN.
4.4.2 User Interface
Adapun user interface dari perangkat lunak kriptografi Algoritma IDEA ini meliputi, halaman utama, Kunci enkripsi, Kunci dekripsi. Untuk lebih jelasnya dapat di lihat di bawah ini.
4.4.2.1 Halaman Utama
Halaman utama merupakan menu utama yang ada dalam sistem kriptografi IDEA, untuk memudahkan user dalam mengoperasikan sistem kriptografi IDEA ini. Halaman utama sistem ini dapat dilihat pada gambar 4.5 berikut:
Gambar 4.7 Halaman Utama
4.4.2.2 Form Encrip Data
Form enkripsi digunakan untuk merubah plainteks menjadi cipherteks.
Tampilan layar enkripsi pada sistem kriptografi IDEA ini dapat dilihat pada gambar 4.6 berikut.
Gambar 4.8 Form Rancangan Proses Enkripsi
4.4.2.3 Form Descript Data
Form deskripsi digunakan untuk mengembalikan cipherteks ke bentuk pesan semula. Tampilan layar dekripsi pada sistem kriptografi IDEA ini dapat dilihat pada gambar 4.7 berikut:
Gambar 4.9 Form Rancangan Proses Dekripsi
BAB V
KESIMPULAN DAN SARAN
5.1 KESIMPULAN
1. Pada proses kriptografi dengan algoritma IDEA memiliki 8 putaran dan di tambah satu lagi putaran transformasi output.
2. Panjang plaintext pada kriptografi algoritma IDEA minimal 64 bit sedangkan panjang kunci 128 bit dan algoritma IDEA menggunakan operasi aljabar yang berbeda-beda yaitu XOR, penambahan modulo 216, perkalian 216+1.
3. Pada proses kriptografi dengan menggunakan metode IDEA ini menggunakan kunci simetris pada proses enkripsi dan deskripsinya.
4. Pada penelitian tugas akhir ini, kriptografi dengan menggunakan metode IDEA penulis menggunakan data berformat text.
5. Pada proses enkripsi dan dekripsi dengan menggunakan metode IDEA, file plaintext awal setelah di enkripsi dengan menggunakan kunci simetris akan menghasilkan file chipertext, lalu file chipertext di dekripsi kembali dengan kunci simetris akan menghasilkan file plaintext awal.
Hasil kriptografi dengan menggunakan metode kriptografi IDEA menghasilkan chippertext dengan karakteristik tertentu. Chipertext yang dihasilkan berbeda-beda untuk setiap plaintext dan kuncinya. Ini sangat efektif jika digunakan untuk pengamanan suatu data atau password. Karena untuk proses Deskripsinya user memerlukan Plain Text dan Kunci. Jika salah satu variabelnya berbeda maka hasil chipper textnya sudah tentu berbeda.
5.2 SARAN
Adapun saran-saran yang dapat penulis berikan selama melakukan penelitian ini guna untuk pengembangan perangkat lunak kriptografi dengan Algoritma IDEA ini adalah:
1. Penulis menyarankan kepada pihak lain yang ingin melanjutkan penelitian lanjutan proses enkripsi dan dekripsi ini dengan format lainnya, seperti untuk gambar, suara dan vidio.
2. Hasil keamanan kriptografi dengan menggunakan Algoritma IDEA dapat dibandingkan dengan penerapan pada Algoritma lain mana yang lebih baik dalam menjamin kerahasiaan datanya.
Ariyus, Dony., Pengantar Ilmu Kriptografi: Teori Analisis dan Implementasi, Edisi Pertama. Yogyakarta: Andi Offset, 2008.
Andriyanto, Tri, dan D.L., Crispina Pardede, Studi Dan Perbandingan Algoritma Idea Dan Algoritma Blowfish,Universitas Gunadarma, ISSN : 1411-6286.
Indriyawan. Eko Pemrogaman Visual Basic 6.0 Menggunakan Array dan Binary.
Yogyakarta : Andi, 2001
Jethefer, Stevens, Studi Dan Perbandingan Algoritma IDEA (International Data Encryption Algorithm) Dengan DES (Data Encryption Standard), ITB, 17, 10-11.
Luzaenah, Lusi, Sistem Pengamanan data Efektif menggunakan teori-teori enkripsi tertentu. Bandung, Gunung Agung, 2009.
Mangkulo, hengky alexander., “Cara Mudah Menguasai Visual Basic 6.0”, Penerbit PT.
Elek Media Komputindo, Jakarta. 2011.
Wahana Komputer: The Best Encryption Tools. Penerbit PT Elex Media Komputindo, Jakarta, 2010.
Wahana Komputer : Memahami Model Enkripsi & Security Data. Penerbit ANDI, Yogyakarta, 2003.