Evaluasi Sistem

4.5 Evaluasi Sistem

4.5.1 Struktur Algoritma Blowfish

Blowfish adalah algoritma kunci simetri, yang berarti menggunakan kunci yang sama untuk melakukan enkripsi dan dekripsi berkas. Blowfish juga merupakan cipher blok, yang berarti selama proses enkripsi dan dekripsi, Blowfish akan membagi pesan menjadi blok-blok dengan ukuran yang sama panjang. Panjang blok untuk algoritma Blowfish adalah 64-bit, yang merupakan multiple (kelipatan) dari 8-bit. Jika bukan merupakan kelipatan dari 8-bit, maka akan ditambahkan bit-bit tambahan (padding) sehingga ukuran untuk tiap blok sama.

Algoritma dalam Blowfish terbagi menjadi dua bagian, yaitu ekspansi kunci (key expansion) dan enkripsi data (data encryption). Proses ekspansi kunci akan melakukan konversi sebuah kunci mulai dari 56-byte (448-bit) sampai beberapa beberapa array sub kunci dengan total mencapai 4168-byte. Sedangkan proses enkripsi data terjadi pada jaringan Feistel, yang mengandung fungsi pengulangan (iterasi) sebanyak enam belas kali.

Blowfish menggunakan jaringan Feistel yang terdiri dari 16 buah putaran. Skema jaringan Feistel pada algoritma Blowfish dapat dilihat pada Gambar 4.15.

Plainteks / X (64-bit)

X L (32-bit)

X R (32-bit)

F( X L ) = ((S 1,a +S 2,b mod 2 32 ) ⊕S 3,c )+S 4,d mod 2 32

X L (32-bit) = a(8-bit),b(8-bit),c(8-bit),d(8-bit)

13 Putaran

P 16

P 18 P 17

Cipherteks (64-bit)

Gambar 4.15. Skema Jaringan Feistel Pada Algoritma Blowfish

Tabel 4.2. Pseudo Code Jaringan Feistel Algoritma Blowfish

Line Pseudo Code

1 Begin

3 Input:

4 X // 64 bit plainteks (8 Karakter ASCII)

5 P1, P2, ..., P18 // 18 sub-keys, Pi dengan i = iterasi

6 F()

// Fungsi iterasi

8 Output:

9 C: 64 bits of cipher text

11 Algorithm:

12 (xL, xR) = X // Bagi X menjadi 2 bagian, 32-bit/bagian

13 Loop on i from = 1 to 16 // Lakukan iterasi

14 xL = xL XOR Pi // Operasi XOR xL dgn Pi

15 xR = F(xL) XOR xR // Operasi XOR F(xL) dgn xR

16 Swap xL and xR // Tukar xL dgn xR

17 End of loop // Akhir looping

18 Swap xL and xR // Tukar lagi xL dgn xR

19 xR = xR XOR P17 // Operasi XOR xR dgn P17 -> xR

20 xL = xL XOR P18 // Operasi XOR xL dgn P18 -> xL

21 C = (xL, xR)

// 64 bit cipherteks

23 End

Tabel 4.3. Pseudo Code fungsi iterasi F()

Line Pseudo Code

1 Begin

3 Input:

4 xL, xR // 32-bit data masukan

5 S1[], S2[], S3[], S4[] // 4 Kotak-S table lookup @ 256 entri

7 Output

8 F(xL) or F(xR)

// 32-bit output data

10 Algorithm

11 (a, b, c, d) = xL // Bagi xL (xR) jadi 4 bagian, @ 8-bit

12 F(xL) = ((S1[a] + S2[b] mod 2**32) XOR S3[c]) + S[d] mod 2**32

13 // ** Operasi Pangkat

15 End

Tabel 4.4. Pseudo Code Pembangkitan Sub-kunci

Line Pseudo Code

1 Begin

3 Input:

4 K // Kunci (private) - 32 bit atau lebih

5 PI

// Bagian biner terkecil dari "pi"

6 = 3.1415927... - 3.0

8 = 0x243f6a8885a308d313198a2e03707344...

10 Output:

11 P1, P2, ..., P18 // 18 32-bit sub-kunci

12 S1[], S2[], S3[], S4[] // 4 Kotak-S, 32-bit @256 elemen arrays

14 Algorithm:

15 (P1, P2, ..., P18, S1[], S2[], S3[], S4[]) = PI

16 K' = (K, K, K, ...) // Ulangi kuncinya -> panjang 18*32 bit

17 (P1, P2, ..., P18) = (P1, P2, ..., P18) XOR K'

18 X = (0x000000, 0x000000) // Setting inisialiasi plainteks

19 X = Blowfish(X) // Menerapkan algoritma Blowfish

20 (P1, P2) = X // Perbarui dua sub-kunci pertama P1 & P2

21 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

22 (P3, P4) = X // Perbarui dua sub-kunci P3 & P4

24 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

25 (P17, P18) = X // Perbarui dua sub-kunci P17 & P18

26 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

27 (S1[0], S1[1]) = X // Perbarui 2 Kotak-S pertama S1[0] & S1[1]

28 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

29 (S1[2], S1[3]) = X // Perbarui 2 Kotak-S S1[2] & S1[3]

31 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

32 (S1[254], S1[255]) = X // Perbarui 2 Kotak-S S1[254] & S1[255]

33 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

34 (S2[0], S2[1]) = X // Perbarui 2 Kotak-S pertama S2[0] & S2[1]

36 X = Blowfish(X) // Terapkan kembali algoritma Blowfish

37 (S4[254], S4[255]) = X // Perbarui 2 Kotak-S S4[254] & S4[255]

39 End

Perlu diketahui bahwa:

1. Untuk menginisalisasi 18 sub-kunci dan 4 Kotak-S, diperlukan (18*32 + 4*256*32) = (576 + 32768) = 33344 digit biner dari Pi, atau 33344/4 = 8366 digit hex dari PI. Untuk mengetahui 8366 digit hex dari Pi, dapat dilihat pada lampiran kode program (Lampiran 1).

2. Untuk menyelesaikan ke 18 sub-kunci dan 4 Kotak-S, diperlukan penerapan algoritma Blowfish sebanyak (18+(4*256))/2 = 521 kali.

4.5.2 Uji Coba Aplikasi

Berdasarkan sistem yang telah dibuat, dilakukan evaluasi dan uji coba sistem dengan data masukan sebagai berikut:

Tabel 4.5. Data Masukan Uji Coba Aplikasi Proses Enkripsi

Performance III Mode

Performance I

Performance II

(22 B)

(206.076 B / 202 KB)

(1.052.629 B / 1 MB)

C T (ms) ECB

C T (ms)

C T (ms)

Time (ms)

Perf 1 600

Perf 2 Perf 3

Mode Enkripsi

Gambar 4.16. Chart Waktu Enkripsi Tiap Mode

Tabel 4.6. Data Masukan Uji Coba Aplikasi Proses Dekripsi

Performance III Mode

Performance I

Performance II

(22 B)

(206.076 B / 202 KB)

(1.052.629 B / 1 MB)

C T (ms) ECB

C T (ms)

C T (ms)

e ( 600 Perf 1

Mode Dekripsi

Gambar 4.17 Chart Waktu Dekripsi Tiap Mode Berdasarkan data-data di atas, terlihat bahwa running time tiap-tiap mode enkripsi dan dekripsi tidak berbeda jauh secara signifikan.

4.5.3 Analisis Algoritma dengan Notasi big-O

Notasi big O (juga dikenal sebagai Big Oh, notasi Landau, atau notasi Bachmann-Landau) merupakan notasi yang digunakan untuk menggambarkan batasan perilaku dari sebuah fungsi algoritma ketika variabel cenderung ke arah nilai yang tak terbatas. Secara sederhana, notasi big O digunakan untuk menghitung running time dari sebuah algoritma. Walaupun awalnya dikembangkan sebagai bagian dari bidang matematika murni, namun saat ini notasi big O sering digunakan dalam teori kompleksitas komputasi untuk menggambarkan pemakaian algoritma terhadap sumber daya komputasi (computational resources).

Tata cara pemakaian notasi big O dalam sebuah fungsi algoritma:

a. Kurangi semua faktor konstanta dan kembalikan ke nilai 1

2 Contoh: 2 10 n  9  120 n  400  n  1  n  1

b. Buang semua konstanta kecuali satu Contoh: 2 n  1 

c. Buang semua variabel kecuali satu yang paling dominan

Contoh: 2 n  n  1  n . Sehingga nilai notasi big O-nya adalah O( n ) Aturan untuk menentukan kompleksitas waktu asimptotik big O dalam

sebuah pseudo code:

a. Pengisian nilai (assignment), perbandingan, operasi aritmatik, read, write membutuhkan running time O(1)

b. Pengaksesan elemen array atau memilih field tertentu dari sebuah record membutuhkan running time O(1)

c. Perulangan (loop) for . Kompleksitas waktu loop for adalah jumlah pengulangan dikali dengan kompleksitas waktu badan (body) loop. Sederhananya: