Senin, 29 Maret 2010

DES

  1. Algoritma DES dan GOST

    Algoritma DES

DES (data encrytion standard) mengenkrip plaintext sebesar 64 bit (8 byte) dengan panjang kunci sekitar 56 bit (7 byte), sebanyak 16 putaran. Data 64 bit akan disubtitusi terlebih dahulu dengan permutasi IP (initial permutation). IP digunakan sebelum putaran pertama dari 16 putaran, dan mensubtitusi blok input dengan ketentuan sebagai berikut:

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.

Sebagai contoh IP akan memindahkan bit ke-58 dari plaintext menjadi bit ke-1, bit ke-50 menjadi bit ke-2, bit ke-43 menjadi bit ke-3, dan seterusnya.

IP (initial permutation) dan final permutation atau invers IP tidak mempengaruhi keamanan dari DES. Tujuan utamanya yaitu hanya untuk memudahkan dalam memanggil data plaintext atau data ciphertext ke dalam chip DES yang berbentuk potongan-potongan byte dalam software/program komputer.

Plaintext yang telah disubtitusi akan dipecah menjadi dua bagian sebesar 32 bit kiri L dan 32 bit kanan R. pada setiap putarannya data kiri akan menjadi data kanan, data kanan akan dilakukan operasi data kiri di-Xor-kan dengan fungsi f.

          Li=Ri-1

          Ri=Li-1 Xor f(Ri-1,Ki)

Kemudian dilanjutkan dengan melakukan subtitusi final permutation atau invers IP (IPinv). Ipinv merupakan invers dari IP dan digambarkan dengan ketentuan sebagai berikut:

Ipinv = 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.

dalam putaran terakhirnya, blok R16L16 tidak terjadi pertukaran tetapi blok ini menjadi input untuk IPinv.
Untuk fungsi f, data sebelah kanan sebesar 32 bit akan dipermutasi dengan expansion permutation (E) sehingga akan menghasilkan ciphertext sebesar 48 bit, kemudian dilakukan operasi Xor dengan blok kunci dan diinputkan ke dalam sbox. Sbox terdiri atas 8 buah. Hasilnya akan disubtitusi dengan P-Box permutation (P) sekaligus membentuk data menjadi 32 bit lagi. Berikut isi dari E dan P:


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.

P = 16, 7, 20, 21, 29, 12, 28, 17,

    1, 15, 23, 26, 5, 18, 31, 10,

2, 8, 24, 14, 32, 27, 3, 9,

Isi dari Sboxnya adalah sebagai berikut:

S1 = 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,

0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,

4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,

15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,

S2 = 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,

3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,

0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,

13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9.

S3 = 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,

13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,

13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,

1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12.

S4 = 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 5,

13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,

10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,

3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,.

S5 = 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,

14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,

4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,

11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3.

S6 = 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,

10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,

9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,

4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13.

S7 = 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,

13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,

1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,

6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12.

S8 = 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,

1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,

7, 11, 14, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,

2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11.

Blok kunci terdiri atas 16 blok, masing-masing berjumlah 56 bit. Sebelumnya, inputan blok kunci (64 bit) akan didistribusi terlebih dahulu dengan permuted Choice 1 (Pc1) atau disebut juga sebagai Key Permutation (blok kunci menjadi 56 bit), kemudian dipecah menjadi 2 bagian dengan setiap bagian sebesar 28 bit . Setiap blok ke 1, 2, 9, 16 akan dirotasi 1 bit ke kiri, sisanya 2 bit ke kiri kemudian digabungkan kembali menjadi 56 bit. Terakhir dilakukan permutasi dengan Permuted Choice 2 (Pc2) atau disebut juga sebagai Compression Permutation sehingga menjadi 48 bit. Berikut isi dari Pc1 dan Pc2:

Pc1 = 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.

Pc2 = 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.
Analisa Masalah

Dengan berkembangnya sistem komputer dan teknik komunikasi memungkinkan adanya hubungan antar komputer untuk menyalurkan data dari satu komputer ke komputer lain. Maka hal ini dapat menunjang terselesaikannya suatu pekerjaan secara efisien, cepat dan akurat. Namun permasalahannya adalah data tersebut dapat dibaca , dicuri, disalahgunakan, bahkan dirusak oleh pihak-pihak yang tidak bertanggung jawab.

  1. Penyelesaian Masalah

Berdasarkan hal di atas maka salah satu elemen yang paling penting dalam komunikasi menggunakan komputer untuk menjamin kerahasian data adalah enkripsi. Enkripsi adalah sebuah proses yang melakukan sebuah perubahan kode dari yang bisa dimengerti menjadi sebuah kode atau cipher yang tidak bisa dimengerti. Sebuah cipher menggunakan suatu algoritma yang dapat mengkodekan semua aliran data (stream) bit dari sebuah pesan menjadi cryptogram yang tidak dimengerti (unintelligible). Karena teknik cipher merupakan suatu sistem yang telah siap untuk di automasi, maka teknik ini digunakan dalam sebuah sistem keamanan sebuah PC (personal computer)dan sistem keamanan jaringan/network.

Untuk proteksi data yang cukup penting tidak ada jalan lain selain menggunakan program khusus proteksi/enkripsi data. Saat ini telah banyak beredar program khusus proteksi data baik freeware, shareware, maupun komersial yang sangat baik. Pada umumnya program tersebut tidak hanya menyediakan satu metode saja, tetapi beberapa jenis metode.

Teknik enkripsi ada bermacam-macam metode misalnya, DES, TEA, GOST, RSA, Blowfish, Skipjack, Twofish dan lain sebagainya. Pada penulisan tugas akhir Mata Kuliah Sistem Keamanan Lanjut (EC 7010) ini menggunakan algoritma dari metode DES (Data Encryption Standard) dan algoritma dari metode GOST (Gosudarstennyi Standard).

Karena metode DES dan GOST merupaka blok cipher 64 bit (8 byte), kebanyakan data yang dibagi ke dalam 64 bit tidak bulat, oleh sebab itu dalam blok cipher diperlukan data tambahan pada blok terakhir untuk menggenapi blok menjadi 64 bit, hal ini biasanya disebut padding. Data akan ditambahkan dengan bilangan random sebanyak yang dibutuhkan.

Misalkan data berupa text "Enkripsi dan Dekripsi" maka:

Panjang data: 20 byte 20 mod 8 = 4 byte

4 byte tersebut akan diisi oleh bilangan random antara 1 - 255. Misalkan keempat bilangan tersebut secara urut adalah 2, 3, 4, 5, maka data akan menjadi: "Enkripsi dan Dekripsi2345" dan panjang data akan menjadi: 20 + 4 = 24 byte.
  1. Proses Enkripsi

Pada dasarnya proses enkripsi ini terbagi atas 2 tahap, yaitu tahap pertama adalah enkripsi dengan metode DES, dan tahap ke dua enkripsi hasil metode DES dengan metode GOST.

  • Tahap Pertama

Pada tahap pertama dilakukan proses pengenkripsian dengan metode DES. Pertama-tama dilakukan pembentukan subkunci yang terdiri atas 16 blok sepanjang 48 bit (6 byte) setiap bloknya. Terlebih dahulu kunci yang mulanya sepanjang 32 byte akan diambil hanya sepanjang 64 bit (8 byte). Setelah disubtitusi dengan blok Pc1 (permuted choice 1), panjang kunci akan menjadi 56 bit (7 byte). Kemudian untuk setiap blok akan dipecah menjadi 2 bagian (masing-masing 28 bit) dan setiap blok ke 1, 2, 9, 16 akan dirotasi 1 bit ke kiri, sisanya dirotasi 2 bit ke kiri, hasilnya akan disubtitusi lagi dengan blok Pc2 (permuted choice 2) untuk menghasilkan keluaran 48 bit. Pembentukan subkunci akan dijalankan terlebih dahulu, kemudian akan dilakukan pengenkripsian plaintext.

Algoritmanya adalah sebagai berikut:

    1. Panggil Byte2Bin(ByteKey(), 8, KeyBin())
    2. Selama a=0 hingga a=55 lakukan perulangan

      KeySchedule(a)=KeyBin(m_PC1(a))

    1. Akhir perulangan
    2. Panggil CopyMem(c(0), KeySchedule(0), 28)
    3. Panggil CopyMem(d(0), KeySchedule(28), 28)
    4. Selama i=1 hingga i=16 lakukan perulangan
    5. Panggil CopyMem(temp(0), C(0), m_LeftShifts(i))
    6. Panggil CopyMem(c(0), c(m_LeftShifts(i)), 28 - m_LeftShifts(i))
    7. Panggil CopyMem(c(28 - m_LeftShifts(i)), temp(0),

      M_LeftShits(i))

    1. Panggil CopyMem(temp(0), d(0), m_LeftShipts(i))
    2. Panggil CopyMem(d(0), d(m_LeftShifts(i)), 28 - m_LeftShifts(i))
    3. Panggil CopyMem(d(28- m_LeftShifts(i)), temp(0),

    m_LeftShifts(i))

    1. Panggil CopyMem(CD(0), C(0), 28)
    2. Panggil CopyMem(CD(28), d(0), 28)
    3. Selama a=0 hingga a=47 lakukan perulangan

      m_Key(a,I)=CD(m_PC2(a))

    1. Akhir perulangan
    2. Akhir Perulangan
    3. Pesan dimensi Array ByteKey(0 31)

Setelah pembentukan subkey, dilanjutkan dengan melakukan subtitusi plaintext dengan permutasi IP. Plaintext sebesar 64 bit (8 byte) akan dibagi dua masing-masing 32 bit sekaligus disubtitusi dengan m_IP. m_IP merupakan blok bilangan dari inisial permutasi IP. algoritmanya adalah sebagai berikut:

    1. Panggil Byte2Bin(BlockData(), 8, BinBlock())
    2. For a=0 to 31

      L(a)=BinBlock(m_IP(a))

      R(a)=BinBlock(m_IP(a+32))

    1. Next

Fungsi Byte2Bin akan mengubah byte menjadi bit, algoritmanya sebagai berikut:

    1. Panggil CopyMem(BinarryArray(0), m_EmptyArray(0), ByteLen*8)
    2. BinLength=0
    3. Selama a=0 hingga a=(ByteLen-1) lakukan perulangan
    4. ByteValue=ByteArray (a)
    5. Jika (ByteValue and 128) maka BinaryArray(BinLength)=1
    6. Jika (ByteValue and 64) maka BinaryArray(BinLength + 1)=1
    7. Jika (ByteValue and 32) maka BinaryArray(BinLength + 2)=1
    8. Jika (ByteValue and 16) maka BinaryArray(BinLength + 3)=1
    9. Jika (ByteValue and 8) maka BinaryArray(BinLength + 4)=1
    10. Jika (ByteValue and 4) maka BinaryArray(BinLength + 5)=1
    11. Jika (ByteValue and 2) maka BinaryArray(BinLength + 6)=1
    12. Jika (ByteValue and 1) maka BinaryArray(BinLength + 7)=1
    13. BinLength = BinLength + 8
    14. Akhir perulangan

Setelah operasi di atas, selanjutnya data disebelah kanan akan diekspansi menjadi 48 bit (6 byte) yang urutan bitnya sesuai dengan bit E, sekaligus di Xor-kan dengan hasil kunci di atas. Algoritmanya adalah sebagai berikut (i = 1 sampai 16):

    1. ErxorK(0) = r(31) Xor m_Key(0, i )
    2. ErxorK(1) = r(0) Xor m_Key(1, i)
    3. ErxorK(2) = r(1) Xor m_Key(2, i)
    4. ErxorK(3) = r(2) Xor m_Key(3, i)
    5. ErxorK(4) = r(3) Xor m_Key(4, i)
    6. ErxorK(5) = r(4) Xor m_Key(5, i)
    7. ErxorK(6) = r(3) Xor m_Key(6, i)
    8. ErxorK(7) = r(4) Xor m_Key(7, i)
    9. ErxorK(8) = r(5) Xor m_Key(8, i)
    10. ErxorK(9) = r(6) Xor m_Key(9, i)
    11. ErxorK(10) = r(7) Xor m_Key(10, i)
    12. ErxorK(11) = r(8) Xor m_Key(11, i)
    13. ErxorK(12) = r(7) Xor m_Key(12, i)
    14. ErxorK(13) = r(8) Xor m_Key(13, i)
    15. ErxorK(14) = r(9) Xor m_Key(14, i)
    16. ErxorK(15) = r(10) Xor m_Key(15, i)
    17. ErxorK(16) = r(11) Xor m_Key(16, i)
    18. ErxorK(17) = r(12) Xor m_Key(17, i)
    19. ErxorK(18) = r(11) Xor m_Key(18, i)
    20. ErxorK(19) = r(12) Xor m_Key(19, i)
    21. ErxorK(20) = r(13) Xor m_Key(20, i)
    22. ErxorK(21) = r(14) Xor m_Key(21, i)
    23. ErxorK(22) = r(15) Xor m_Key(22, i)
    24. ErxorK(23) = r(16) Xor m_Key(23, i)
    25. ErxorK(24) = r(15) Xor m_Key(24, i)
    26. ErxorK(25) = r(16) Xor m_Key(25, i)
    27. ErxorK(26) = r(17) Xor m_Key(26, i)
    28. ErxorK(27) = r(18) Xor m_Key(27, i)
    29. ErxorK(28) = r(19) Xor m_Key(28, i)
    30. ErxorK(29) = r(20) Xor m_Key(29, i)
    31. ErxorK(30) = r(19) Xor m_Key(30, i)
    32. ErxorK(31) = r(20) Xor m_Key(31, i)
    33. ErxorK(32) = r(21) Xor m_Key(32, i)
    34. ErxorK(33) = r(22) Xor m_Key(33, i)
    35. ErxorK(34) = r(23) Xor m_Key(34, i)
    36. ErxorK(35) = r(24) Xor m_Key(35, i)
    37. ErxorK(36) = r(23) Xor m_Key(36, i)
    38. ErxorK(37) = r(24) Xor m_Key(37, i)
    39. ErxorK(38) = r(25) Xor m_Key(38, i)
    40. ErxorK(39) = r(26) Xor m_Key(39, i)
    41. ErxorK(40) = r(27) Xor m_Key(40, i)
    42. ErxorK(41) = r(28) Xor m_Key(41, i)
    43. ErxorK(42) = r(27) Xor m_Key(42, i)
    44. ErxorK(43) = r(28) Xor m_Key(43, i)
    45. ErxorK(44) = r(29) Xor m_Key(44, i)
    46. ErxorK(45) = r(30) Xor m_Key(45, i)
    47. ErxorK(46) = r(31\) Xor m_Key(46, i)
    48. ErxorK(47) = r(0) Xor m_Key(47, i)

Kemudian hasil di atas akan disubtitusikan dengan m_sBox (blok Sbox DES) sebanyak 6 bit yang menhasilkan keluaran 4 bit ditampung dalam array sBox sebanyak 32 bit. Algoritmanya sebagai berikut:

    1. Panggil CopyMem(sBox(0),m_sBox(0, ErxorK(0),

    ERxorK(1), ERxorK(2), ERxorK(3), ERxorK(4), ERxorK(5)),4)

    1. Panggil CopyMem(sBox(4),m_sBox(1, ErxorK(6),

    ERxorK(7), ERxorK(8), ERxorK(9), ERxorK(10), ERxorK(11)),4)

    1. Panggil CopyMem(sBox(8),m_sBox(2, ErxorK(12),

    ERxorK(13), ERxorK(14), ERxorK(15), ERxorK(16), ERxorK(17)),4)

    1. Panggil CopyMem(sBox(12),m_sBox(3, ErxorK(18),

    ERxorK(19), ERxorK(20), ERxorK(21), ERxorK(22), ERxorK(23)),4)

    1. Panggil CopyMem(sBox(16),m_sBox(4, ErxorK(24),

    ERxorK(25), ERxorK(26), ERxorK(27), ERxorK(28), ERxorK(29)),4)

    1. Panggil CopyMem(sBox(20),m_sBox(5, ErxorK(30),

    ERxorK(31), ERxorK(32), ERxorK(33), ERxorK(34), ERxorK(35)),4)

    1. Panggil CopyMem(sBox(24),m_sBox(6, ErxorK(36),

    ERxorK(37), ERxorK(38), ERxorK(39), ERxorK(40), ERxorK(41)),4)

    1. Panggil CopyMem(sBox(28),m_sBox(7, ErxorK(42),

    ERxorK(43), ERxorK(44), ERxorK(45), ERxorK(46), ERxorK(47)),4)

Setelah sBox dihasilkan, kemudian hasilnya akan di Xor-kan dengan data sebelah kiri dengan urutan bit sesuai dengan m_P Permutasi dari blok P) dan hasilnya akan ditampung dalam array LiRi sebanyak 32 bit. Algoritmanya sebagai berikut:

    1. LiRi(0) = L(0) Xor sBox(15)
    2. LiRi(1) = L(1) Xor sBox(6)
    3. LiRi(2) = L(2) Xor sBox(19)
    4. LiRi(3) = L(3) Xor sBox(20)
    5. LiRi(4) = L(4) Xor sBox(28)
    6. LiRi(5) = L(5) Xor sBox(11)
    7. LiRi(6) = L(6) Xor sBox(27)
    8. LiRi(7) = L(7) Xor sBox(16)
    9. LiRi(8) = L(8) Xor sBox(0)
    10. LiRi(9) = L(9) Xor sBox(14)
    11. LiRi(10) = L(10) Xor sBox(22)
    12. LiRi(11) = L(11) Xor sBox(25)
    13. LiRi(12) = L(12) Xor sBox(4)
    14. LiRi(13) = L(13) Xor sBox(17)
    15. LiRi(14) = L(14) Xor sBox(30)
    16. LiRi(15) = L(15) Xor sBox(9)
    17. LiRi(16) = L(16) Xor sBox(1)
    18. LiRi(17) = L(17) Xor sBox(7)
    19. LiRi(18) = L(18) Xor sBox(23)
    20. LiRi(19) = L(19) Xor sBox(13)
    21. LiRi(20) = L(20) Xor sBox(31)
    22. LiRi(21) = L(21) Xor sBox(36)
    23. LiRi(22) = L(22) Xor sBox(2)
    24. LiRi(23) = L(23) Xor sBox(8)
    25. LiRi(24) = L(24) Xor sBox(18)
    26. LiRi(25) = L(25) Xor sBox(12)
    27. LiRi(26) = L(26) Xor sBox(29)
    28. LiRi(27) = L(27) Xor sBox(5)
    29. LiRi(28) = L(28) Xor sBox(21)
    30. LiRi(29) = L(29) Xor sBox(10)
    31. LiRi(30) = L(30) Xor sBox(3)
    32. LiRi(31) = L(31) Xor sBox(24)

Hasil data diatas akan dijadikan data sebelah kanan, data kiri diisi dengan data kanan sebelumnya lalu keduanya disatukan kembali menjadi data 64 bit kembali sekaligus disubtitusi dengan m_IP dan 64 bit tersebut dijadikan 8 byte kembali. m_IP merupakan blok bilangan dari invers permutasi pada DES. Algoritmanya sebagai berikut:

    1. Panggil CopyMem(RL(0), r(0), 32)
    2. Panggil CopyMem(RL(32), L(0), 32)
    3. Selama a=0 hingga a=63 lakukan perulangan

      BinBlock(a)=RL(m_IPInv(a))

    1. Akhir perulangan
    2. Panggil Bin2Byte(BinBlock(), 8, BlockData())

Fungsi Bin2Byte akan mengubah bin menjadi byte, algoritmanya sebagai berikut:

    1. BinLength=0
    2. Selama a=0 hingga a=(ByteLen - 1) lakukan perulangan
    3. ByteValue=0
    4. Jika (BinarryArray(BinLength)=1)maka ByteValue=ByteValue+128
    5. Jika (BinarryArray(BinLength+1)=1)maka ByteValue=ByteValue+64
    6. Jika (BinarryArray(BinLength+2)=1)maka ByteValue=ByteValue+32
    7. Jika (BinarryArray(BinLength+3)=1)maka ByteValue=ByteValue+16
    8. Jika (BinarryArray(BinLength+4)=1)maka ByteValue=ByteValue+8
    9. Jika (BinarryArray(BinLength+5)=1)maka ByteValue=ByteValue+4
    10. Jika (BinarryArray(BinLength+6)=1)maka ByteValue=ByteValue+2
    11. Jika (BinarryArray(BinLength+7)=1)maka ByteValue=ByteValue+1
    12. ByteArray(a)=ByteValue
    13. BinLength=BinLength + 8
    14. Akhir perulangan

Langkah-langkah di atas dilakukan sebanyak 16 kali / 16 putaran (round), dan hasilnya akan dijadikan input untuk proses enkripsi dengan metode Gost. Perlu diperhatikan disini, yaitu setiap blok IP, blok invers IP, blok Sbox, blok P, blok E, blok Pc1, dan blok Pc2 pada metode DES adalah blok yang isinya merupakan ketetapan dari algoritma DES.

  • Tahap Kedua

Pada tahap ke dua ini, subkunci untuk Gost terdiri sebanyak 8 buah blok dengan panjang setiap bloknya adalah 32 bit. Untuk mempersulit, maka setiap bloknya akan dirotasi 11 bit ke kiri. Algoritmanya adalah sebagai berikut:

    1. K1 =SB_X(ByteKey(),0)
    2. K2 =SB_X(ByteKey(),4)
    3. K3 =SB_X(ByteKey(),8)
    4. K4 =SB_X(ByteKey(),12)
    5. K5 =SB_X(ByteKey(),16)
    6. K6 =SB_X(ByteKey(),20)
    7. K7 =SB_X(ByteKey(),24)
    8. K8 =SB_X(ByteKey(),28)

Algoritma untuk fungsi SB_Xnya adalah sebagai berikut:

    1. bb(0) = ByteKey(offset)
    2. bb(1) = ByteKey(offset + 1)
    3. bb(2) = ByteKey(offset + 2)
    4. bb(3) = ByteKey(offset + 3)
    5. F0 =TBin(aa)
    6. F1 = TBin(bb)
    7. F2 = TBin(cc)
    8. F3 = TBin(dd)
    9. temp = F0 & F1 & F2 & F3
    10. Putar1 = Mid$(Temp, 1, 11)
    11. Putar2 = Mid$(Temp, 12, 22)
    12. temp = putar1 & putar2
    13. bb(0) = TDec(Mid$(Temp, 1, 8))
    14. bb(1) = TDec(Mid$(Temp, 9, 8))
    15. bb(2) = TDec(Mid$(Temp, 17, 8))
    16. bb(3) = TDec(Mid$(Temp, 25, 8))
    17. temp = Chr$(bb(0)) & Chr$(bb(1)) & Chr$(bb(2)) & Chr$(bb(3))
    18. x() = Konversi temp ke from Unicode
    19. panggil GetWord(has, x(), 0)
    20. SB_X = has

Kemudian plaintext berupa hasil enkripsi dari metode DES akan dipecah menjadi dua bagian, yaitu 32 bit (4 byte) kiri dan 32 bit (4 byte) kanan. Setiap blok kiri dan kanan akan diubah menjadi satu bilangan 32 bit. Algoritmanya sebagai berikut:

    1. Panggil GetWord(LeftWord, ByteArray(), Offset)
    2. Panggil GetWord(LeftWord, ByteArray(), Offset + 4)

    Algoritma untuk GetWordnya adalah sebagai berikut:

    1. CryptBuffer(3) = bb(Offset)
    2. CryptBuffer(2) = bb(Offset + 1)
    3. CryptBuffer(1) = bb(Offset + 2)
    4. CryptBuffer(0) = bb(Offset + 3)
    5. Panggil CopyMem(LongValue, CryptBuffer(0),4)

Untuk pengembalian nilainya, data kiri ataupun kanan akan dipisah kembali menjadi 4 bilangan (masing-masing 8 bit). Algoritmanya sebagai berikut:

    1. Panggil PutWord(LeftWord, ByteWord(), Offset)
    2. Panggil PutWord(LeftWord, ByteWord(), Offset + 4)

Algoritma untuk PutWordnya adalah sebagai berikut:

    1. Panggil CopyMem(CryptBuffer(0), LongValue, 4)
    2. aByte(Offset) = CryptBuffer(3)
    3. aByte(Offset + 1) = CryptBuffer(2)
    4. aByte(Offset + 2) = CryptBuffer(1)
    5. aByte(Offset + 3) = CryptBuffer(0)

Setelah dibentuk subkey, dilanjutkan dengan melakukan enkripsi plaintext sebanyak 32 putaran dengan operasi:

    Li = RI-1

    Ri = LI-1 xor f(RI-1,Ki)

Algoritma untuk operasi di atas adalah sebagai berikut:

    1. selama i=1 hingga i=3 lakukan perulangan
    2. Temp = LeftWord
    3. LeftWord = RightWord
    4. RightWord = Temp Xor F (RightWord, K1)
    5. Temp = LeftWord
    6. LeftWord = RightWord
    7. RightWord = Temp Xor F (RightWord, K2)
    8. Temp = LeftWord
    9. LeftWord = RightWord
    10. RightWord = Temp Xor F (RightWord, K3)
    11. Temp = LeftWord
    12. LeftWord = RightWord
    13. RightWord = Temp Xor F (RightWord, K4)
    14. Temp = LeftWord
    15. LeftWord = RightWord
    16. RightWord = Temp Xor F (RightWord, K5)
    17. Temp = LeftWord
    18. LeftWord = RightWord
    19. RightWord = Temp Xor F (RightWord, K6)
    20. Temp = LeftWord
    21. LeftWord = RightWord
    22. RightWord = Temp Xor F (RightWord, K7)
    23. Temp = LeftWord
    24. LeftWord = RightWord
    25. RightWord = Temp Xor F (RightWord, K8)
    26. Akhir perulangan
    27. Temp = LeftWord
    28. LeftWord = RightWord
    29. RightWord = Temp Xor F (RightWord, K8)
    30. Temp = LeftWord
    31. LeftWord = RightWord
    32. RightWord = Temp Xor F (RightWord, K7)
    33. Temp = LeftWord
    34. LeftWord = RightWord
    35. RightWord = Temp Xor F (RightWord, K6)
    36. Temp = LeftWord
    37. LeftWord = RightWord
    38. RightWord = Temp Xor F (RightWord, K5)
    39. Temp = LeftWord
    40. LeftWord = RightWord
    41. RightWord = Temp Xor F (RightWord, K4)
    42. Temp = LeftWord
    43. LeftWord = RightWord
    44. RightWord = Temp Xor F (RightWord, K3)
    45. Temp = LeftWord
    46. LeftWord = RightWord
    47. RightWord = Temp Xor F (RightWord, K2)
    48. Temp = LeftWord
    49. LeftWord = RightWord
    50. RightWord = Temp Xor F (RightWord, K1)

Untuk fungsi F, blok data sebelah kanan akan dijumlahkan dengan blok kunci. Setiap perulangan akan digunakan blok kunci yang berbeda. Untuk mencegah terjadinya overflow, maka datanya akan dilakukan operasi byte per byte modulus 255. Kemudian hasilnya dipecah menjadi 2 bilangan, dan disubtitusi dengan Sbox dari Gost. Hasil keluaran dari Sbox akan digunakan kembali menjadi bilangan 32 bit. Terakhir bilangan tersebut akan dirotasi 11 bit ke kiri. Algoritmanya adalah sebagai berikut:

    1. R = RightWord
    2. K = Key
    3. Addval = unsignedHelp(R,K)
    4. F = Addval

Algoritma untuk fungsi unsignedHelp:

    1. Panggil PutWord(R,a(),0)
    2. Panggil PutWord(Key,b(),0)
    3. Count = 0
    4. Selama m=0 hingga m=3 lakukan perulangan
    5. Addval = CLng(a(m))+CLng(b(m))
    6. Addval = Addval Mod 255
    7. d = 1
    8. selama n=0 hingga n=1 lakukan perulangan
    9. KeyWord(n) = Tdec("0000" & Mid$(Tbin(Addval),d,4))
    10. Tempbit(count) = SboxGhost(count,KeyWord(n))
    11. Count = count + 1
    12. d = d + 4
    13. Akhir perulangan
    14. akhir perulangan
    15. m = 0
    16. Selama m=0 hingga m=7 lakukan perulangan
    17. TempString = TempString & Mid$(Tbin(tempbit(m)),5,4)
    18. Akhir Perulangan
    19. TempString = Mid$(TempString,12,21) & Mid$(TempString,1,11)
    20. c(0) = TDec(Mid$(TempString,1,8))
    21. c(1) = TDec(Mid$(TempString,7,8))
    22. c(2) = TDec(Mid$(TempString,17,8))
    23. c(3) = TDec(Mid$(TempString,25,8))
    24. Panggil GetWord(Addval, c(), ))
    25. unsignedHelp = Addval

Total bilangan yang dihasilkan dari operasi di atas untuk disubtitusi ke Sbox berjumlah 8 buah bilangan. Dalam metode Gost, tidak ditentukan standar dalam pembuatan Sboxnya, sehingga ada kemungkinan Sbox yang dibuat akan kurang baik. Sbox yang akan digunakan merupakan Sbox yang sama dengan yang digunakan oleh Central Bank of The Russian Federation.

Setelah proses selesai, nilai bilangan kiri dan kanan akan dikembalikan lagi menjadi 64 bit (8byte). Algoritmanya adalah sebagai berikut:

Panggil PutWord(LeftWord,ByteArray(),Offset)

Panggil PutWord(RightWord,ByteCipher(), Offset + 4)

Ciphertext yang dihasilakan akan diubah ke dalam bentuk string lagi dan disimpan ke dalam file baru. di sini file asli tidak akan diganti dengan file hasil enkripsi. File baru akan dibuat untuk menampung hasil enkripsi. Header file dan jumlah penambahan adata akan ditambahkan ke dalam file baru ini. Jika file baru sudah ada, maka akan dihapus dahulu kemudian diisi kembali dengan hasil enkripsi tersebut.

  1. Proses Dekripsi

Proses ini merupakan kebalikan dari proses enkripsi yaitu proses mengembalikan data yang terenkripsi menjadi data yang sebenarnya. Pada dasarnya proses dekripsi ini terbagi atas 2 tahap, yaitu tahap pertama adalah dekripsi dengan metode GOST, dan tahap ke dua dekripsi dengan metode DES. Pada proses dekripsi ini juga dilakukan tahapan-tahapan yang sama seperti pada tahapan enkripsi.

  • Tahap Pertama

Untuk fungsi f pada GOST, algoritma dekripsinya sama dengan algoritma enkripsinya. Sebelum melakukan dekripsi, kunci akan didekripsi terlebih dahulu. Pada fungsi f data kanan akan menjadi data kiri kemudian sebaliknya, dan setiap putaran akan menggunakan blok kunci yang berbeda, dimulai dari blok kunci terakhir. Algoritmanya adalah sebagai berikut:

    1. Temp = LeftWord
    2. LeftWord = RightWord
    3. RightWord = Temp Xor F (RightWord, K1)
    4. Temp = LeftWord
    5. LeftWord = RightWord
    6. RightWord = Temp Xor F (RightWord, K2)
    7. Temp = LeftWord
    8. LeftWord = RightWord
    9. RightWord = Temp Xor F (RightWord, K3)
    10. Temp = LeftWord
    11. LeftWord = RightWord
    12. RightWord = Temp Xor F (RightWord, K4)
    13. Temp = LeftWord
    14. LeftWord = RightWord
    15. RightWord = Temp Xor F (RightWord, K5)
    16. Temp = LeftWord
    17. LeftWord = RightWord
    18. RightWord = Temp Xor F (RightWord, K6)
    19. Temp = LeftWord
    20. LeftWord = RightWord
    21. RightWord = Temp Xor F (RightWord, K7)
    22. Temp = LeftWord
    23. LeftWord = RightWord
    24. RightWord = Temp Xor F (RightWord, K8)
    25. Selama i=1 hingga i=3 lakukan perulangan
    26. Temp = RightWord
    27. RightWord = LeftWord
    28. LeftWord = Temp Xor F (LeftWord, K8)
    29. Temp = RightWord
    30. RightWord = LeftWord
    31. LeftWord = Temp Xor F (LeftWord, K7)
    32. Temp = RightWord
    33. RightWord = LeftWord
    34. LeftWord = Temp Xor F (LeftWord, K6)
    35. Temp = RightWord
    36. RightWord = LeftWord
    37. LeftWord = Temp Xor F (LeftWord, K5)
    38. Temp = RightWord
    39. RightWord = LeftWord
    40. LeftWord = Temp Xor F (LeftWord, K4)
    41. Temp = RightWord
    42. RightWord = LeftWord
    43. LeftWord = Temp Xor F (LeftWord, K3)
    44. Temp = RightWord
    45. RightWord = LeftWord
    46. LeftWord = Temp Xor F (LeftWord, K2)
    47. Temp = RightWord
    48. RightWord = LeftWord
    49. LeftWord = Temp Xor F (LeftWord, K1)
    50. Akhir perulangan

  • Tahap Kedua

Sama seperti GOST, pada DES algoritmanya akan sama dengan algoritma enkripsinya, hanya yang berbeda yaitu data kanan akan dijadikan data kiri dan sebaliknya dengan 16 blok kunci akan dimulai dari blok kunci terakhir. Algoritmanya adalah sebagai berikut (dengan i = 16 samapai 1):

    1. ERxorK(0) = r(31) Xor m_Key(0, i )
    2. ERxorK(1) = r(0) Xor m_Key(1, i)
    3. ERxorK(2) = r(1) Xor m_Key(2, i)
    4. ERxorK(3) = r(2) Xor m_Key(3, i)
    5. ERxorK(4) = r(3) Xor m_Key(4, i)
    6. ERxorK(5) = r(4) Xor m_Key(5, i)
    7. ERxorK(6) = r(3) Xor m_Key(6, i)
    8. ERxorK(7) = r(4) Xor m_Key(7, i)
    9. ERxorK(8) = r(5) Xor m_Key(8, i)
    10. ERxorK(9) = r(6) Xor m_Key(9, i)
    11. ERxorK(10) = r(7) Xor m_Key(10, i)
    12. ERxorK(11) = r(8) Xor m_Key(11, i)
    13. ERxorK(12) = r(7) Xor m_Key(12, i)
    14. ERxorK(13) = r(8) Xor m_Key(13, i)
    15. ERxorK(14) = r(9) Xor m_Key(14, i)
    16. ERxorK(15) = r(10) Xor m_Key(15, i)
    17. ERxorK(16) = r(11) Xor m_Key(16, i)
    18. ERxorK(17) = r(12) Xor m_Key(17, i)
    19. ERxorK(18) = r(11) Xor m_Key(18, i)
    20. ERxorK(19) = r(12) Xor m_Key(19, i)
    21. ERxorK(20) = r(13) Xor m_Key(20, i)
    22. ERxorK(21) = r(14) Xor m_Key(21, i)
    23. ERxorK(22) = r(15) Xor m_Key(22, i)
    24. ERxorK(23) = r(16) Xor m_Key(23, i)
    25. ERxorK(24) = r(15) Xor m_Key(24, i)
    26. ERxorK(25) = r(16) Xor m_Key(25, i)
    27. ERxorK(26) = r(17) Xor m_Key(26, i)
    28. ERxorK(27) = r(18) Xor m_Key(27, i)
    29. ERxorK(28) = r(19) Xor m_Key(28, i)
    30. ERxorK(29) = r(20) Xor m_Key(29, i)
    31. ERxorK(30) = r(19) Xor m_Key(30, i)
    32. ERxorK(31) = r(20) Xor m_Key(31, i)
    33. ERxorK(32) = r(21) Xor m_Key(32, i)
    34. ERxorK(33) = r(22) Xor m_Key(33, i)
    35. ERxorK(34) = r(23) Xor m_Key(34, i)
    36. ERxorK(35) = r(24) Xor m_Key(35, i)
    37. ERxorK(36) = r(23) Xor m_Key(36, i)
    38. ERxorK(37) = r(24) Xor m_Key(37, i)
    39. ERxorK(38) = r(25) Xor m_Key(38, i)
    40. ERxorK(39) = r(26) Xor m_Key(39, i)
    41. ERxorK(40) = r(27) Xor m_Key(40, i)
    42. ERxorK(41) = r(28) Xor m_Key(41, i)
    43. ERxorK(42) = r(27) Xor m_Key(42, i)
    44. ERxorK(43) = r(28) Xor m_Key(43, i)
    45. ERxorK(44) = r(29) Xor m_Key(44, i)
    46. ERxorK(45) = r(30) Xor m_Key(45, i)
    47. ERxorK(46) = r(31\) Xor m_Key(46, i)
    48. ERxorK(47) = r(0) Xor m_Key(47, i)
Untuk proses selebihnya sama persis dengan waktu enkripsi pada metode DES. Setelah proses di atas selesai, ciphertext akan menjadi plaintext dan disimpan kembali ke dalam file tersebut dengan nama sebelumnya.
Kesimpulan dan Saran
  • Kesimpulan

Berdasarkan analisa yang telah dilakukan, dapat diambil kesimpulan bahwa:

  1. Penyandian dengan metode DES yang dikombinasikan dengan metode GOST cukup memadai untuk menangkal penyerangan data oleh user yang tidak berhak terutama ditinjau dari tingkat kesulitan dalam memecahkan penyandian.
  2. Pengenkripsian kunci pada awal program dan kunci pada metode GOST dapat lebih menyulitkan dalam memecahkan penyandian pada ciphertext.
  3. Perancang GOST mencoba mengambil keseimbangan antara efisiensi dan keamanan. Mereka memodifikasi design dasar DES untuk menciptakan algoritma yang lebih baik dalam implementasinya pada software. Mereka juga kurang yakin dalam keamanan algoritmanya, dan mencoba untuk melengkapinya dengan membuat panjang kuncinya (256 bit), tetap merahasiakan dari Sboxnya, dan melipatgandakan jumlah iterasinya (32 putaran).


referensi
http://74.125.153.132/search?q=cache:AQqxz73wOUoJ:budi.insan.co.id/courses/ec7010/2004-2005/budi-report.rtf+Metode+DES&cd=4&hl=id&ct=clnk&gl=id

disusun oleh :
Aji Nugroho 2007-53-198
Zuliana Putri Dewi 2007-53-202
Ahmad teguh Susilo 2007-53-240
Lilik Chusnawati 2007-53-241
Diposting oleh di

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)