ini dulu adalah tugas yang diberikan dosen kepada saya yaitu membuat aplikasi DES pakai bahasa apa aja. nah kemaren iseng-iseng pake C#. sebenernya sih penasaran pake bahasa C# soalnya belum pernah bikin program pake C# *malu*. yasudah biar ga lupa saya tulis aja diblog.
sejarah
- 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.
algoritma
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. secara global algorima digambarkan sebagai berikut :
menurut gambar diatas bisa diceritaken seperti ini :
- Blok plainteks dipermutasi dengan matriks permutasi awal (initial permutation atau IP).
- Hasil permutasi awal kemudian di-enciphering- sebanyak 16 kali (16 putaran). Setiap putaran menggunakan kunci internal yang berbeda.
- Hasil enciphering kemudian dipermutasi dengan matriks permutasi balikan (invers initial permutation atau IP-1 ) menjadi blok cipherteks.
perlu penjelasan plantext itu adalah text mentah. misalnya nulis di notepad itu adalah plaintextnya. pokonya bisa dibaca oleh manusialah itu namanya plaintext. nah nantinya plaintext itu dijadiin bit-bit gitu. misal huruf a itu binarynya 01100001. jadi kalo misal ada plaintext: bayu, maka binarynya 01100010011000010111100101110101. huruf besar dan huruf kecil berbeda binarynya. setelah itu binary yang tersusun dari plaintext dipecah-pecah tiap 64 bit. nanti tiap 64 bit itu akan dipermutasikan sama matriks permutasi (IP). berikut matriks 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 |
cara baca matriks IP ini adalah dari kiri atas ke kanan. arti dari matriks ini adalah memindahkan/mengacak posisi 64 bit plaintext. cara kerjanya adalah dengan memindahkan bit ke 58 ke posisi 1, bit ke 50 ke posisi 2, dst. contohnya seperti ini:
plintext : bayucaem
binary : 0110001001100001011110010111010101100011011000010110010101101101
jika sudah diacak oleh matriks IP akan menjadi:
| 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
| 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
begini code-nya dalam c#:
pertama jadikan plaintext ke binary :
setelah jadi tuh binary, dibagi-bagi tiap 64 bit.
jika sudah dibagi-bagi menjadi 64 bit maka di permutasikan dengan matriks IP
setelah tahap permutasi selesai dilakukan maka sekarang menuju ke tahap enchipering. disni butuh yang namanya kunci eksternal yang akan membentuk kunci internal. jadi gambarannya sang user jika ingin mengenkripsi maka ada dua yang harus diinputkan yaitu plaintextnya dan kuncinya sepanjang 16 digit hexadesimal. kunci ini juga (selanjutnya disebut kunci eksternal) akan digunakan pada saat mendekripsi DES.
diperlukan 16 kunci internal untuk digunakan dalam putaran enchipering. untuk mendapatkannya pertama, kunci external yang diinputkan oleh user dalam bentuk hexadesimal diubah kebentuk biner kemudian dipermutasikan oleh matriks PC-1. ini matriksnya :
| 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 | 46 | 38 | 30 | 22 |
| 14 | 6 | 61 | 53 | 45 | 37 | 29 | 21 | 13 | 5 | 28 | 20 | 12 | 4 |
cara permutasinya sama dengan permutasi plaintext dan mengahsilkan 56 bit dari 64 bit kunci eksternal. setelah didapatkan hasil dari permutasi maka hasil permutasi tadi dibagi dua, yaitu bagian kiri dan kanan masing-masing 28 bit. Selanjutnya, kedua bagian digeser ke kiri (left shift) sepanjang satu atau dua bit bergantung pada tiap putaran. Operasi pergeseran bersifat wrapping atau round-shift. Jumlah pergeseran pada setiap putaran ditunjukkan pada Tabel 1 sbb:
| Putaran, i | Jumlah pergeseran bit |
| 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 |
setelah digeser, masing-masing digabungkan kembali dan kembali lagi dipermutasikan. tetapi matriks yang digunakan adalah matriks 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 |
ilustrasinya begini:
key eksternal inputan user : ab12781bac253987
binernya:
| 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 |
| 0 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 |
| 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 |
| 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 |
setelah dipermutasikan dengan pc-1 dan dibagi menjadi dua bagian (L0 dan R0)
L0
| 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |
| 0 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 |
R0
| 1 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 |
karena ini adalah putaran pertama maka L0 dan R0 masing-masing digeser kekiri 1 kali menurut tabel pergeseran diatas, hasilnya begini setelah L0 dan R0 digeser dan digabung kembali kemudian dipermutasikan dengan pc-2
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 |
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 |
| 0 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 1 |
dalam hexadecimal : 432c1248d7c5
itulah key internal pertama yang didapatkan. untuk mendapatkan key/kunci internal yang kedua cukup key yang pertama dibagi masing-masing 24 bit kiri dan kanan setelah itu digeser menurut table pergesaran dan dipermutasikan dengan pc-2. berikut key internal lengkapnya :
| Key eksternal : ab12781bac253987 | |
| no | key |
| 1 | 432c1248d7c5 |
| 2 | 50422d7cb8e8 |
| 3 | 81912420fc7f |
| 4 | 800ae72fbcb2 |
| 5 | b17220ad4d73 |
| 6 | 8017e00fca56 |
| 7 | d05255d5c5d4 |
| 8 | 05d3408986cd |
| 9 | e621187136f8 |
| 10 | 0e861139b82f |
| 11 | 4f181a267cb6 |
| 12 | 2ea0c82d29f7 |
| 13 | 1a4c0aa7c8d3 |
| 14 | 682918478757 |
| 15 | 04ac0d9f85cc |
| 16 | 9805c455366e |
implementasi pembentukan kunci dalam bahasa c# sebagai berikut :
pertama adalah menerima input dari user berupa hexadesimal kemudian inputan tersebut dijadikan biner:
bilangan biner yang di dapat akan dilakukan permutasi dengan pc-1. fungsi yang digunakan adalah fungsi permutasi yang dilakukan pada plaintext hanya berbeda array matriksnya saja. setelah itu dibagi dua masing-masing menjadi L0 dan R0:
setelah itu adalah pergesaran pada kedua bagian tersebut
setelah digeser proses terakhir adalah menggabungkan L0 dan R0 lalu dilakukan permutasi pada matriks pc-2. nah untuk fungsi permutasi yang digunakan adalah fungsi pada permutasi pada plaintext, hanya saja array yang digunakan adalah array matriks pc-2.
capek juga nulis segini. besok dilanjut lagi ya proses selanjutnya sampai akhir. sekalian nanti program utuhnya di upload yang mau sedot monggo. kalo ada yang salah monggo dibenahi dan tinggalkan komen anda. 
lanjutannya dimari.
