Algoritma RSA

RSA merupakan algoritma kriptografi asimetri, dimana kunci yang digunakan untuk mengenkripsi berbeda dengan yang digunakan untuk mendekripsi. Kunci yang digunakan untuk mengenkripsi disebut dengan kunci public, dan yang digunakan untuk mendekripsi disebut dengan kunci privat. RSA adalah salah satu algoritma kriptografi yang menggunakan konsep kriptografi kunci publik. RSA membutuhkan tiga langkah dalam prosesnya, yaitu pembangkitan kunci, enkripsi, dan dekripsi. Proses enkripsi dan dekripsi merupakan proses yang hampir sama. Jika bilangan acak yang dibangkitkan kuat, maka akan lebih sulit untuk melakukan cracking terhadap pesan. Parameter kuat tidaknya suatu kunci terdapat pada besarnya bilangan acak yang digunakan.

Untuk pembangkitan pasangan kunci RSA, digunakan algoritma sebagai berikut: 

1. Dipilih dua buah bilangan prima sembarang yang besar, p dan q. Nilai p dan q harus dirahasiakan. 
2. Dihitung n = p x q. Besaran n tidak perlu dirahasiakan. 
3. Dihitung m = (p – 1)(q – 1). Besaran m perlu dirahasiakan. 
4. Dipilih sebuah bilangan bulat sebagai kunci publik, disebut namanya e, yang relatif prima terhadap m. e relatif prima terhadap m artinya faktor pembagi terbesar keduanya adalah 1, secara matematis disebut gcd (e,m) = 1. Untuk mencarinya dapat digunakan algoritma Euclid. Nilai e bersifat tidak rahasia. 
5. Dihitung kunci privat, disebut namanya d sedemikian agar (d x e) mod m = 1. Untuk mencari nilai d yang sesuai dapat juga digunakan algoritma Extended Euclid. Nilai D bersifat rahasia.

Maka hasil dari algoritma tersebut diperoleh : 

1. kunci publik adalah pasangan (e,n). Bersifat tidak rahasia. 
2. kunci private adalah pasangan (d,n). Bersifat rahasia 

Algoritma Enkripsi/Dekripsi 

Enkripsi 

• Ambil kunci publik penerima pesan, e, dan n 
• Nyatakan plainteks M menjadi blok-blok M1, M2, …, sedemikian sehingga setiap blok merepresentasikan nilai di dalam selang [0, n – 1]. 
• Setiap blok Mi dienkripsi menjadi blok Ci dengan rumus Ci = Mi ^ e mod n 

Dekripsi 

• Setiap blok cipherteks Ci didekripsi kembali menjadi blok Mi dengan rumus Mi = Ci ^ d mod n

Algoritma Euclid

Algoritma ini mencari FPB dengan cara melakukan pembagian berulang-ulang dimulai dari kedua bilangan yang hendak kita cari FPBnya sampai kita mendapatkan sisa 0 dari hasil pembagian.

Marilah kita lihat contoh yang lain, cari FPB dari 40 dan 64 :

• 64 ÷ 40 = 1 dengan sisa 24 
• 40 ÷ 24 = 1 dengan sisa 16 
• 24 ÷ 16 = 1 dengan sisa 8 
• 16 ÷ 8 = 2 dengan sisa 0.

Kita berhenti di sini sebab kita sudah mendapat sisa 0. Bilangan terakhir yang kita gunakan untuk membagi adalah 8, jadi FPB dari 40 dan 64 adalah 8 

Contoh lain, cari FPB 3337 dan 79 :

• 3337 ÷ 79 = 42 dengan sisa 19 
• 79 ÷ 19 = 4 dengan sisa 3 
• 19 ÷ 3 = 6 dengan sisa 1 

Kita berhenti karena sudah mendapatkan sisa 1.

Contoh RSA Sederhana 

1. p = 47 dan q = 71 (keduanya prima). 
2. n = p ⋅ q = 3337 
3. m = (p – 1)(q – 1) = 3220 
4. Pilih e yg relativ prime terhadap m, gcd(e,m) = 1.
   e = 79 => gcd(79, 3337) = 1 
5. Cari nilai d, d*e = 1 mod (m) 

          d*79 = 1 mod 3220
          d*79 mod 3220 = 1

          d = 1019

Sehingga didapatkan : 

1. Public key : (79, 3337) 
2. Private key : (1019, 3337) 

Proses Enkripsi

Setelah didapat perhitungan di atas, maka akan dilakukan enkripsi plaintext M = AKU. Pertama-tama plaintext tersebut diubah menjadi format ASCII sebagai berikut : 

Karakter          A                K           U 

ASCII             65               75          85 

M1 = 657 M2 = 585

Setelah dibagi perblock, maka akan dihitung menggunakan rumus Ci = Mi ^ e mod n. 

• C1 = 657 ^ 79 mod 3337 = 2349 
• C2 = 585 ^ 79 mod 3337 = 685 

Maka, chipertext yang didapatkan adalah C = 320328

Proses Dekripsi

Setelah chipertext dari kata AKU didapat, untuk mengubahnya kembali jadi plaintext menggunakan dekripsi dengan rumus Mi = Ci ^ d mod n. 

• M1 = 2349 ^ 1019 mod 3337 = 657 
• M2 = 685 ^ 1019 mod 3337 = 585 

Maka, setelah di dekripsi hasilnya akan sama. Yaitu 657585.

Algoritma DES ( Data Encryption Standart )

DES (Data Encryption Standard) adalah algoritma cipher blok yang populer karena dijadikan standard algoritma enkripsi kunci-simetri, meskipun saat ini standard tersebut telah digantikan dengan algoritma yang baru, AES, karena DES sudah dianggap tidak aman lagi. Sebenarnya DES adalah nama standard enkripsi simetri, nama algoritma enkripsinya sendiri adalah DEA (Data Encryption Algorithm), namun nama DES lebih populer daripada DEA. Algoritma DES dikembangkan di IBM dibawah kepemimpinan W.L. Tuchman pada tahun 1972. Algoritma ini didasarkan pada algoritma Lucifer yang dibuat oleh Horst Feistel. Algoritma ini telah disetujui oleh National Bureau of Standard (NBS) setelah penilaian kekuatannya oleh National Security Agency (NSA) Amerika Serikat.

DES termasuk ke dalam sistem kriptografi simetri dan tergolong jenis cipher blok. DES beroperasi pada ukuran blok 64 bit. DES mengenkripsikan 64 bit plainteks menjadi 64 bit cipherteks dengan menggunakan 56 bit kunci internal (internal key) atau upa-kunci (subkey). Kunci internal dibangkitkan dari kunci eksternal (external key) yang panjangnya 64 bit.

Gambar 6.1 Skema global algoritma DES

Skema global dari algoritma DES adalah sebagai berikut (lihat Gambar 6.1):

1. Blok plainteks dipermutasi dengan matriks permutasi awal (initial permutation atau IP).

2. Hasil permutasi awal kemudian di-enciphering- sebanyak 16 kaH (16 putaran). Setiap putaran menggunakan kunci internal yang berbeda.

3. Hasil enciphering kemudian dipermutasi dengan matriks permutasi balikan (invers initial permutation atau IP-1 ) menjadi blok cipherteks.

Di dalam proses enciphering, blok plainteks terbagi menjadi dua bagian, kiri (L) dan kanan R), yang masing-masing panjangnya 32 bit. Kedua bagian ini masuk ke dalam 16 putaran DES. Pada setiap putaran i, blok R merupakan masukan untuk fungsi transformasi yang ;isebut f. Pada fungsi f, blok R dikombinasikan dengan kunci internal K,. Keluaran dai =angsi f di-XOR-kan dengan blok L untuk mendapatkan blok R yang baru. Sedangkan blok - yang baru langsung diambil dari blok R sebelumnya. Ini adalah satu putaran DES. Secara watematis, satu putaran DES dinyatakan sebagai

Li=Ri-1 (6.1)

R i=L i-1 f(Ri-1, K i) (6.2)

Gambar 6.3 memperlihatkan skema algoritma DES yang lebih rinci. Satu putaran DES merupakan model jaringan Feistel (lihat Gambar 6.2). Perlu dicatat dari Gambar 6.2 bahwa ika (L,6, R,6) merupakan keluaran dari putaran ke-16, maka (R,6, L,s) merupakan pra­:ipherteks (pre-ciphertext) dari enciphering ini. Cipherteks yang sebenarnya diperoleh dengan melakukan permutasi awal balikan, IP-1, terhadap blok pra-cipherteks.

Gambar 6.2. Jaringan Feistel untuk satu putaran DES

Gambar 6.3 Algoritma Enkripsi dengan DES Permutasi Awal

Langkah-langkah mengenkripsi data menggunakan algoritma DES(Data Encryption System) yaitu:

Diberikan contoh:

·                     Plaintext(x) = COMPUTER

·                     Key(k) = 13 34 57 79 9B BC DF F1

Langkah Pertama :

Ubahlah plaintext kedalam bentuk biner
C : 01000011
O : 01001111
M : 01001101
P : 01010000
U : 01010101
T : 01010100
E : 01000101
R : 01010010

Ubahlah key kedalam bentuk biner
13 : 00010011
34 : 00110100
57 : 01010111
79 : 01111001
9B : 10011011
BC : 10111100
DF : 11011111
F1 : 11110001



Langkah Kedua :

Lakukan Initial Permutation (IP) pada bit plaintext menggunakan tabel IP berikut:

Tabel Initial Permutation(IP)

58	50	42	34	26	18	10	2
60	52	44	36	28	20	12	4
62	54	46	38	30	22	14	6
64	56	48	40	32	24	16	8
57	49	41	33	25	17	9	1
59	51	43	35	27	19	11	3
61	53	45	37	29	21	13	5
63	55	47	39	31	23	15	7

Urutan bit pada plaintext urutan ke 58 ditaruh diposisi 1,
Urutan bit pada plaintext urutan ke 50 ditaruh di posisi 2,
Urutan bit pada plaintext urutan ke 42 ditaruh di posisi 3, dst

Sehingga hasil outputnya adalah

IP(x) : 11111111 10111000 01110110 01010111 00000000 00000000 00000110 10000011

Pecah bit pada IP(x) menjadi 2 bagian yaitu:
L₀ : 11111111 10111000 01110110 01010111 (tabel IP dengan warna kuning)
R₀ : 00000000 00000000 00000110 10000011 (tabel IP dengan warna hijau)

Langkah Ketiga :

Generate kunci yang akan digunakanuntuk mengenkripsi plaintext dengan menggunakan tabel permutasi kompresi PC-1, pada langkah ini terjadi kompresi dengan membuang 1 bit masing-masing blok kunci dari 64 bit menjadi 56 bit.

Tabel PC-1

57	49	41	33	25	17	9
1	58	50	42	34	26	18
10	2	59	51	43	35	27
19	11	3	60	52	44	36
63	55	47	39	31	23	15
7	62	54	45	38	30	22
14	6	61	53	45	37	29
21	13	5	28	20	12	4

Dapat kita lihat pada tabel diatas, tidak terdapat urutan bit 8,16,24,32,40,48,56,64 karena telah dikompress. Berikut hasil outpunya :

CD(k) : 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111

Pecah CD(k) menjadi dua bagian kiri dan kanan, sehingga menjadi

C₀ : 1111000 0110011 0010101 0101111(tabel PC-1 warna kuning)
D₀ : 0101010 1011001 1001111 0001111 (tabel PC-1 warna hijau)

Langkah Keempat :

Lakukan pergeseran kiri (Left Shift) pada C₀ dan D₀, sebanyak 1 atau 2 kali berdasarkan kali putaran yang ada pada tabel putaran sebagai berikut:

Tabel Left Shift

Putaran ke - i	Jumlah Pergeseran(Left Shift)
1	1
2	1
3	2
4	2
5	2
6	2
7	2
8	2
9	1
10	2
11	2
12	2
13	2
14	2
15	2
16	1

Untuk putaran ke 1, dilakukan pegeseran 1 bit ke kiri
Untuk putaran ke 2, dilakukan pergeseran 1 bit kekiri
Untuk putaran ke 3, dilakukan pergeseran 2 bit kekiri, dst

Berikut hasil outputnya:
C₀ : 1111000 0110011 0010101 0101111
D₀ : 0101010 1011001 1001111 0001111

Digeser 1 bit ke kiri
C₁ : 1110000 1100110 0101010 1011111
D₁ : 1010101 0110011 0011110 0011110

Digeser 2 bit ke kiri
C₂ : 1100001 1001100 1010101 0111111
D₂ : 0101010 1100110 0111100 0111101

Digeser 2 bit ke kiri
C₃ : 0000110 0110010 1010101 1111111
D₃ : 0101011 0011001 1110001 1110101

Digeser 2 bit ke kiri
C₄ : 0011001 1001010 1010111 1111100
D₄ : 0101100 1100111 1000111 1010101

Digeser 2 bit ke kiri
C₅ : 1100110 0101010 1011111 1110000
D₅ : 0110011 0011110 0011110 1010101

Digeser 2 bit ke kiri
C₆ : 0011001 0101010 1111111 1000011
D₆ : 1001100 1111000 1111010 1010101

Digeser 2 bit ke kiri
C₇ : 1100101 0101011 1111110 0001100
D₇ : 0110011 1100011 1101010 1010110

Digeser 2 bit ke kiri
C₈ : 0010101 0101111 1111000 0110011
D₈ : 1001111 0001111 0101010 1011001

Digeser 1 bit ke kiri
C₉ : 0101010 1011111 1110000 1100110
D₉ : 0011110 0011110 1010101 0110011

Digeser 2 bit ke kiri
C₁₀ : 0101010 1111111 1000011 0011001
D₁₀ : 1111000 1111010 1010101 1001100

Digeser 2 bit ke kiri
C₁₁ : 0101011 1111110 0001100 1100101
D₁₁ : 1100011 1101010 1010110 0110011

Digeser 2 bit ke kiri
C₁₂ : 0101111 1111000 0110011 0010101
D₁₂ : 0001111 0101010 1011001 1001111

Digeser 2 bit ke kiri
C₁₃ : 0111111 1100001 1001100 1010101
D₁₃ : 0111101 0101010 1100110 0111100

Digeser 2 bit ke kiri
C₁₄ : 1111111 0000110 0110010 1010101
D₁₄ : 1110101 0101011 0011001 1110001

Digeser 2 bit ke kiri
C₁₅ : 1111100 0011001 1001010 1010111
D₁₅ : 1010101 0101100 1100111 1000111

Digeser 1 bit ke kiri
C₁₆ : 1111000 0110011 0010101 0101111
D₁₆ : 0101010 1011001 1001111 0001111

Setiap hasil putaran digabungkan kembali menjadi C_iD_i dan diinput kedalam tabel Permutation Compression 2 (PC-2) dan terjadi kompresi data C_iD_i 56 bit menjadi CiDi 48 bit.

Tabel PC-2

14	17	11	24	1	5
3	28	15	6	21	10
23	19	12	4	26	8
16	7	27	20	13	2
41	52	31	37	47	55
30	40	51	45	33	48
44	49	39	56	34	53
46	42	50	36	29	32

Berikut hasil outputnya:

C₁D₁ = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110
K₁ = 000110 110000 001011 101111 111111 000111 000001 110010 

C₂D₂ = 1100001 1001100 1010101 0111111 0101010 1100110 0111100 0111101
K₂ = 011110 011010 111011 011001 110110 111100 100111 100101 

C₃D₃ = 0000110 0110010 1010101 1111111 0101011 0011001 1110001 1110101
K₃ = 010101 011111 110010 001010 010000 101100 111110 011001 

C₄D₄ = 0011001 1001010 1010111 1111100 0101100 1100111 1000111 1010101
K₄ = 011100 101010 110111 010110 110110 110011 010100 011101 

C₅D₅ = 1100110 0101010 1011111 1110000 0110011 0011110 0011110 1010101
K₅ = 011111 001110 110000 000111 111010 110101 001110 101000 

C₆D₆ = 0011001 0101010 1111111 1000011 1001100 1111000 1111010 1010101
K₆ = 011000 111010 010100 111110 010100 000111 101100 101111 

C₇D₇ = 1100101 0101011 1111110 0001100 0110011 1100011 1101010 1010110
K₇ = 111011 001000 010010 110111 111101 100001 100010 111100 

C₈D₈ = 0010101 0101111 1111000 0110011 1001111 0001111 0101010 1011001
K₈ = 111101 111000 101000 111010 110000 010011 101111 111011 

C₉D₉ = 0101010 1011111 1110000 1100110 0011110 0011110 1010101 0110011
K₉ = 111000 001101 101111 101011 111011 011110 011110 000001 

C₁₀D₁₀ = 0101010 1111111 1000011 0011001 1111000 1111010 1010101 1001100
K₁₀ = 101100 011111 001101 000111 101110 100100 011001 001111 

C₁₁D₁₁ = 0101011 1111110 0001100 1100101 1100011 1101010 1010110 0110011
K₁₁ = 001000 010101 111111 010011 110111 101101 001110 000110 

C₁₂D₁₂ = 0101111 1111000 0110011 0010101 0001111 0101010 1011001 1001111
K₁₂ = 011101 010111 000111 110101 100101 000110 011111 101001 

C₁₃D₁₃ = 0111111 1100001 1001100 1010101 0111101 0101010 1100110 0111100
K₁₃ = 100101 111100 010111 010001 111110 101011 101001 000001 

C₁₄D₁₄ = 1111111 0000110 0110010 1010101 1110101 0101011 0011001 1110001
K₁₄ = 010111 110100 001110 110111 111100 101110 011100 111010 

C₁₅D₁₅ = 1111100 0011001 1001010 1010111 1010101 0101100 1100111 1000111
K₁₅ = 101111 111001 000110 001101 001111 010011 111100 001010 

C₁₆D₁₆ = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111
K₁₆ = 110010 110011 110110 001011 000011 100001 011111 110101

Langkah Kelima :

Pada langkah ini, kita akan meng-ekspansi data R_i-1 32 bit menjadi R_i 48 bit sebanyak 16 kali putaran dengan nilai perputaran 1<= i <=16 menggunakan Tabel Ekspansi (E).

Tabel Ekspansi(E)

32	1	2	3	4	5
4	5	6	7	8	9
8	9	10	11	12	13
12	13	14	15	16	17
16	17	18	19	20	21
20	21	22	23	24	25
24	25	26	27	28	29
28	29	30	31	32	1

Hasil E(R_i-1) kemudian di XOR dengan K_i dan menghasilkan Vektor Matriks A_i.

Berikut hasil outputnya:

Iterasi  1
E(R(1)-1) = 100000 000000 000000 000000 000000 001101 010000 000110
K1           = 000110 110000 001011 101111 111111 000111 000001 110010
---------------------------------------------------------------------------------------- XOR
A1           = 100110 110000 001011 101111 111111 001010 010001 110100


{
UPDATE (18 maret 2015) , berhubung bagian dibawah ini yang paling ribet, maka saya tambahkan keterangan ditengah-tengah proses iterasi. Bisa kita lihat pada iterasi1 diatas setelah kita dapatkan hasil XOR antara E(R(1)-1) dengan K1 dan menghasilkan A1, maka proses berikutnya langsung masuk ke LANGKAH KEENAM terlebih dahulu, dimana A1 akan dimasukan ke dalam S-Box dan menghasilkan output B1.
B1 kemudian akan dipermutasikan lagi dengan tabel P-Box dan menghasilkan nilai PB1 yang kemudian di XOR-kan dengan L0 dan menghasilkan nilai R1. Nilai R1 ini digunakan untuk melanjutkan iterasi ke-2.
}


Iterasi – 2
E(R(2)-1) = 011010 101110 100001 010110 100110 100101 010000 001101
K2           = 011110 011010 111011 011001 110110 111100 100111 100101
---------------------------------------------------------------------------------------- XOR
A2           = 000100 110100 011010 001111 010000 011001 110111 101000

Iterasi – 3
E(R(3)-1) = 010001 010111 111011 110011 110001 010101 010010 100001
K3           = 010101 011111 110010 001010 010000 101100 111110 011001
---------------------------------------------------------------------------------------- XOR
A3           = 000100 001000 001001 111001 100001 111001 101100 111000

Iterasi – 4
E(R(4)-1) = 010111 110001 010111 110011 110101 011100 001111 110001
K4           = 011100 101010 110111 010110 110110 110011 010100 011101
---------------------------------------------------------------------------------------- XOR
A4           = 001011 011011 100000 100101 000011 101111 011011 101100

Iterasi – 5
E(R(5)-1) = 110110 101001 011100 000101 011001 011010 100110 100011
K5           = 011111 001110 110000 000111 111010 110101 001110 101000
---------------------------------------------------------------------------------------- XOR
A5           = 101001 100111 101100 000010 100011 101111 101000 001011

Iterasi – 6
E(R(6)-1) = 100101 011011 110001 010110 101110 101100 000111 111010
K6           = 011000 111010 010100 111110 010100 000111 101100 101111
---------------------------------------------------------------------------------------- XOR
A6           = 111101 100001 100101 101000 111010 101011 101011 010101

Iterasi – 7
E(R(7)-1) = 110010 100001 011111 110010 100111 111101 011001 010011
K7           = 111011 001000 010010 110111 111101 100001 100010 111100
---------------------------------------------------------------------------------------- XOR
A7           = 001001 101001 001101 000101 011010 011100 111011 101111

Iterasi – 8
E(R(8)-1) = 111100 001010 101001 010101 010011 110000 001010 100011
K8           = 111101 111000 101000 111010 110000 010011 101111 111011
---------------------------------------------------------------------------------------- XOR
A8           = 000001 110010 000001 101111 100011 100011 100101 011000

Iterasi – 9
E(R(9)-1) = 010010 101111 111000 000000 000010 101111 110101 010001
K9           = 111000 001101 101111 101011 111011 011110 011110 000001
---------------------------------------------------------------------------------------- XOR
A9           = 101010 100010 010111 101011 111001 110001 101011 010000

Iterasi – 10
E(R(10)-1)= 100111 111000 001110 100010 100111 110111 111000 001010
K10          = 101100 011111 001101 000111 101110 100100 011001 001111
---------------------------------------------------------------------------------------- XOR
A10          = 001011 100111 000011 100101 001001 010011 100001 000101

Iterasi – 11
E(R(11)-1)= 010011 110111 111010 101010 101111 110011 110001 011001
K11          = 001000 010101 111111 010011 110111 101101 001110 000110
---------------------------------------------------------------------------------------- XOR
A11          = 011011 100010 000101 111001 011000 011110 111111 011111

Iterasi – 12
E(R(12)-1)= 001001 011010 101001 011111 110001 010111 110010 101100
K12          = 011101 010111 000111 110101 100101 000110 011111 101001
---------------------------------------------------------------------------------------- XOR
A12          = 010100 001101 101110 101010 010100 010001 101101 000101

Iterasi – 13
E(R(13)-1)= 100110 100111 110111 111011 111110 101110 101100 001010
K13          = 100101 111100 010111 010001 111110 101011 101001 000001
---------------------------------------------------------------------------------------- XOR
A13          = 000011 011011 100000 101010 000000 000101 000101 001011

Iterasi – 14
E(R(14)-1)= 111001 010111 110000 001000 001000 001000 001011 111011
K14          = 010111 110100 001110 110111 111100 101110 011100 111010
---------------------------------------------------------------------------------------- XOR
A14          = 101110 100011 111110 111111 110100 100110 010111 000001

Iterasi – 15
E(R(15)-1)= 000110 101100 001100 000001 011001 011010 100101 010100
K15          = 101111 111001 000110 001101 001111 010011 111100 001010
---------------------------------------------------------------------------------------- XOR
A15          = 101001 010101 001010 001100 010110 001001 011001 011110

Iterasi – 16
E(R(16)-1)= 101101 011101 010100 000101 010101 010001 010110 100010
K16          = 110010 110011 110110 001011 000011 100001 011111 110101
---------------------------------------------------------------------------------------- XOR
A16          = 011111 101110 100010 001110 010110 110000 001001 010111

Langkah Keenam :

Setiap Vektor A_i disubstitusikan kedelapan buah S-Box(Substitution Box), dimana blok pertama disubstitusikan dengan S₁, blok kedua dengan S₂ dan seterusnya dan menghasilkan output vektor B_i32 bit.
S1 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	14	4	13	1	2	15	11	8	3	10	6	12	5	9	0	7
01	0	15	7	4	14	2	13	1	10	6	12	11	9	5	3	8
10	4	1	14	8	13	6	2	11	15	12	9	7	3	10	5	0
11	15	12	8	2	4	9	1	7	5	11	3	14	10	0	6	13

S2 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	15	1	8	14	6	11	3	4	9	7	2	13	12	0	5	10
01	3	13	4	7	15	2	8	14	12	0	1	10	6	9	11	5
10	0	14	7	11	10	4	13	1	5	8	12	6	9	3	2	15
11	13	8	10	1	3	15	4	2	11	6	7	12	0	5	14	9

S3 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	10	0	9	14	6	3	15	5	1	13	12	7	11	4	2	8
01	13	7	0	9	3	4	6	10	2	8	5	14	12	11	15	1
10	13	6	4	9	8	15	3	0	11	1	2	12	5	10	14	7
11	1	10	13	0	6	9	8	7	4	15	14	3	11	5	2	12

S4 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	7	13	14	3	0	6	9	10	1	2	8	5	11	12	4	15
01	13	8	11	5	6	15	0	3	4	7	2	12	1	10	14	9
10	10	6	9	0	12	11	7	13	15	1	3	14	5	2	8	4
11	3	15	0	6	10	1	13	18	9	4	5	11	12	7	2	14

S5 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	2	12	4	1	7	10	11	6	8	5	3	15	13	0	14	9
01	14	11	2	12	4	7	13	1	5	0	15	10	3	9	8	15
10	4	2	1	11	10	13	7	8	15	9	12	5	6	3	0	14
11	11	8	12	7	1	14	2	13	6	15	0	9	10	4	5	3

S6 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	12	1	10	15	9	2	6	8	0	13	3	4	14	7	5	11
01	10	15	4	2	7	12	9	5	6	1	13	14	0	11	3	8
10	9	14	15	5	2	8	12	3	7	0	4	10	1	13	11	6
11	4	3	2	12	9	5	15	10	11	14	1	7	6	0	8	13

S7 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	4	11	2	14	15	0	8	13	3	12	9	7	5	10	6	1
01	13	0	11	7	4	9	1	10	14	3	5	12	2	15	8	6
10	1	4	11	13	12	3	7	14	10	15	6	8	0	5	9	2
11	6	11	13	8	1	4	10	7	9	5	0	15	14	2	3	12

S8 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	13	2	8	4	6	15	11	1	10	9	3	14	5	0	12	7
01	1	15	13	8	10	3	7	4	12	5	6	11	0	14	9	2
10	7	11	4	1	9	12	14	2	0	6	10	13	15	3	5	8
11	2	1	14	7	4	10	8	13	15	12	9	0	3	5	6	11

Cara menggunakan S-Box :
(Untuk detail penggunaan S-Box, silahkan lihat dihalaman http://en.wikipedia.org/wiki/S-box)

Kita ambil contoh S1, kemudian konversi setiap angka didalam tabel S1 yang berwarna putih menjadi biner, sehingga menjadi bentuk seperti dibawah:

S1 :

	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
00	1110	0100	1101	0001	0010	1111	1011	1000	0011	1010	0110	1100	0101	1001	0000	0111
01	0000	1111	0111	0100	1110	0010	1101	0001	1010	0110	1100	1011	1001	0101	0011	1000
10	0100	0001	1110	1000	1101	0110	0010	1011	1111	1100	1001	0111	0011	1010	0101	0000
11	1111	1100	1000	0010	0100	1001	0001	0111	0101	1011	0011	1110	1010	0000	0110	1101

Kemudian kita ambil sampel blok bit pertama dari A₁ yaitu 100110
Kita pisahkan blok menjadi 2 yaitu:

·                     Bit pertama dan terakhir yaitu 1 dan 0 digabungkan menjadi 10

·                     Bit kedua hingga ke lima 0011

Kemudian dibandingkan dengan memeriksa perpotongan antara keduanya didapatkan nilai 1000(warna merah) dan seterusnya untuk blok kedua hingga blok kedelapan kita bandingkan dengan S2 hingga S8.

Berdasarkan cara diatas diperoleh hasil sebagai berikut:

B₁ = 1000 0101 0100 1000 0011 0010 1110 1010
B₂ = 1101 1100 0100 0011 1000 0000 1111 1001
B₃ = 1101 0110 0011 1100 1011 0110 0111 1111
B₄ = 0010 1001 1101 0000 1011 1010 1111 1110
B₅ = 0100 0001 0011 1101 1000 1010 1100 0011
B₆ = 0110 1101 1101 1100 0011 0101 0100 0110
B₇ = 1110 0011 0110 1011 0000 0101 0010 1101
B₈ = 0000 1000 1101 1000 1000 0011 1101 0101
B₉ = 0110 1110 1110 0001 1010 1011 0100 1010
B₁₀ = 0010 0001 0111 0000 0100 0001 0110 1101
B₁₁ = 0101 1110 0000 1100 1101 1011 1100 0010
B₁₂ = 0110 1000 0000 1011 0011 0110 1010 1101
B₁₃ = 1111 1001 1101 1011 0010 0100 1011 0011
B₁₄ = 1011 1000 0111 1110 1100 0101 1100 0001
B₁₅ = 0100 0001 0011 1001 1111 0111 0010 0111
B₁₆ = 1000 0001 0110 1010 1111 0111 0100 1011

Langkah Ketujuh:

Setelah didapatkan nilai vektor B_i, langkah selanjutnya adalah memutasikan bit vektor B_imenggunakan tabel P-Box, kemudian dikelompokkan menjadi 4 blok dimana tiap-tiap blok memiliki 32 bit data.

Tabel P-Box

16	7	20	21	29	12	28	17
1	15	23	26	5	18	31	10
2	8	24	14	32	27	3	9
19	13	30	6	22	11	4	25

Sehingga hasil yang didapat adalah sebagai berikut:

P(B₁) = 00101000 10110011 01000100 11010001
P(B₂) = 10001011 11011001 10001100 00010011
P(B₃) = 01101111 10110010 10011100 11111110
P(B₄) = 00111111 00111011 01000111 10100001
P(B₅) = 10010101 00110010 11011000 01000101
P(B₆) = 00100100 00011011 11110011 11111000
P(B₇) = 11001000 11000001 11101110 01101100
P(B₈) = 00000111 00111001 00101001 01100001
P(B₉) = 11011001 00111011 10100011 10010100
P(B₁₀) = 00001100 00010101 01101110 00100100
P(B₁₁) = 01110001 00111110 10110000 01010011
P(B₁₂) = 10101000 01101000 10001110 11101001
P(B₁₃) = 10000110 11001011 11001111 11001011
P(B₁₄) = 00000101 11011101 00111010 01001111
P(B₁₅) = 10100101 00100110 11101100 11101100
P(B₁₆) = 00101001 11110111 01101000 11001100

Hasil P(Bi) kemudian di XOR kan dengan Li-1 untuk mendapatkan nilai Ri.
Sedangkan nilai Li sendiri diperoleh dari Nilai Ri-1 untuk nilai 1 <= i <= 16.

L0     = 11111111 10111000 01110110 01010111
R0     = 00000000 00000000 00000110 10000011

P(B1)      = 00101000 10110011 01000100 11010001
L(1)-1    = 11111111 10111000 01110110 01010111
------------------------------------------------------------------------------------------XOR
R1    = 11010111 00001011 00110010 10000110

P(B2)      = 10001011 11011001 10001100 00010011
L(2)-1    = 00000000 00000000 00000110 10000011
------------------------------------------------------------------------------------------XOR
R2    = 10001011 11011001 10001010 10010000

P(B3)      = 01101111 10110010 10011100 11111110
L(3)-1    = 11010111 00001011 00110010 10000110
------------------------------------------------------------------------------------------XOR
R3    = 10111000 10111001 10101110 01111000

P(B4)      = 00111111 00111011 01000111 10100001
L(4)-1    = 10001011 11011001 10001010 10010000
------------------------------------------------------------------------------------------XOR
R4    = 10110100 11100010 11001101 00110001

P(B5)      = 10010101 00110010 11011000 01000101
L(5)-1    = 10111000 10111001 10101110 01111000
------------------------------------------------------------------------------------------XOR
R5    = 00101101 10001011 01110110 00111101

P(B6)      = 00100100 00011011 11110011 11111000
L(6)-1    = 10110100 11100010 11001101 00110001
------------------------------------------------------------------------------------------XOR
R6    = 10010000 11111001 00111110 11001001

P(B7)      = 11001000 11000001 11101110 01101100
L(7)-1    = 00101101 10001011 01110110 00111101
------------------------------------------------------------------------------------------XOR
R7    = 11100101 01001010 10011000 01010001

P(B8)      = 00000111 00111001 00101001 01100001
L(8)-1    = 10010000 11111001 00111110 11001001
------------------------------------------------------------------------------------------XOR
R8    = 10010111 11000000 00010111 10101000

P(B9)      = 11011001 00111011 10100011 10010100
L(9)-1    = 11100101 01001010 10011000 01010001
------------------------------------------------------------------------------------------XOR
R9    = 00111100 01110001 00111011 11000101

P(B10)  = 00001100 00010101 01101110 00100100
L(10)-1    = 10010111 11000000 00010111 10101000
------------------------------------------------------------------------------------------XOR
R10    = 10011011 11010101 01111001 10001100

P(B11)  = 01110001 00111110 10110000 01010011
L(11)-1    = 00111100 01110001 00111011 11000101
------------------------------------------------------------------------------------------XOR
R11    = 01001101 01001111 10001011 10010110


P(B12)  = 10101000 01101000 10001110 11101001
L(12)-1    = 10011011 11010101 01111001 10001100
------------------------------------------------------------------------------------------XOR
R12    = 00110011 10111101 11110111 01100101

P(B13)  = 10000110 11001011 11001111 11001011
L(13)-1    = 01001101 01001111 10001011 10010110
------------------------------------------------------------------------------------------XOR
R13    = 11001011 10000100 01000100 01011101

P(B14)  = 00000101 11011101 00111010 01001111
L(14)-1    = 00110011 10111101 11110111 01100101
------------------------------------------------------------------------------------------XOR
R14    = 00110110 01100000 11001101 00101010

P(B15)  = 10100101 00100110 11101100 11101100
L(15)-1    = 11001011 10000100 01000100 01011101
------------------------------------------------------------------------------------------XOR
R15    = 01101110 10100010 10101000 10110001

P(B16)  = 00101001 11110111 01101000 11001100
L(16)-1    = 00110110 01100000 11001101 00101010
------------------------------------------------------------------------------------------XOR

R16    = 00011111 10010111 10100101 11100110

L16    = 01101110 10100010 10101000 10110001

Langkah Kedelapan:

Langkah terakhir adalah menggabungkan R₁₆ dengan L₁₆ kemudian dipermutasikan untuk terakhir kali dengan tabel Invers Initial Permutasi(IP^-1).

Tabel IP^-1

40	8	48	16	56	24	64	32
39	7	47	15	55	23	63	31
38	6	46	14	54	22	62	30
37	5	45	13	53	21	61	29
36	4	44	12	52	20	60	28
35	3	43	11	51	19	59	27
34	2	42	10	50	18	58	26
33	1	41	9	49	17	57	25

Sehingga Input :
R₁₆L₁₆ =  00011111 10010111 10100101 11100110 01101110 10100010 10101000 10110001

Menghasilkan Output:
Cipher(dalam biner) = 01010110 11110001 11010101 11001000 01010010 10101111 10000001 00111111