Kamis, 17 Januari 2013

Proses Enkripsi Plainteks Algoritma Kriptografi GOST



      
  KRIPTOGRAFI METODE GOST
          
 Proses Enkripsi

 Plaintext/Teks Asli:
 --------------------
 'Komputer'

 Konversi plaintext ke nilai biner:
 ----------------------------------
 Nilai biner dari karakter 'K' = 01001011
 Nilai biner dari karakter 'o' = 01101111
 Nilai biner dari karakter 'm' = 01101101
 Nilai biner dari karakter 'p' = 01110000
 Nilai biner dari karakter 'u' = 01110101
 Nilai biner dari karakter 't' = 01110100
 Nilai biner dari karakter 'e' = 01100101
 Nilai biner dari karakter 'r' = 01110010

 Hasil penggabungan binernya (64 bit):
 -------------------------------------
 01001011-01101111-01101101-01110000-01110101-01110100-01100101-01110010


 Enkripsi putaran ke-0:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(0) = 01001110101001100010111010101110
    R(0) = 00001110101101101111011011010010

 2. 32 bit bagian kanan, R(0) ditambah dengan upa-kunci K(0)
    modulus 2^32, R(0) + K(0) Mod 2^32:
    ---------------------------------------------------------
    R(0) = 00001110101101101111011011010010 = 246871762
    K(0)  = 10010010101100100010101011001010 = 2461149898
          =(246871762 + 2461149898) Mod 2 ^ 32 = 2708021660
          = 1010-0001-0110-1001-0010-0001-1001-1100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1010 = 10 --> SBOX(0) --> 1 = 0001
    0001 = 1 --> SBOX(1) --> 11 = 1011
    0110 = 6 --> SBOX(2) --> 4 = 0100
    1001 = 9 --> SBOX(3) --> 4 = 0100
    0010 = 2 --> SBOX(4) --> 7 = 0111
    0001 = 1 --> SBOX(5) --> 11 = 1011
    1001 = 9 --> SBOX(6) --> 10 = 1010
    1100 = 12 --> SBOX(7) --> 6 = 0110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 00011011010001000111101110100110
    Setelah Rotate Left Shift: 00100011110111010011000011011010

 5. Lakukan proses XOR pada R(0) dan L(0) untuk mendapatkan
    R(1), R(1) = R(0) XOR L(0):
    ---------------------------------------------------------
    R(0) = 00100011110111010011000011011010
    L(0) = 01001110101001100010111010101110
           ---------------------------------- XOR
    R(1) = 01101101011110110001111001110100

 6. Untuk mendapatkan L(1), nilai R(0) diambil sebelum proses
    L(1) = R(0) sebelum proses:
    -----------------------------------------------------------
    L(1) = 00001110101101101111011011010010

 Enkripsi putaran ke-1:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(1) = 00001110101101101111011011010010
    R(1) = 01101101011110110001111001110100

 2. 32 bit bagian kanan, R(1) ditambah dengan upa-kunci K(1)
    modulus 2^32, R(1) + K(1) Mod 2^32:
    ---------------------------------------------------------
    R(1) = 01101101011110110001111001110100 = 1836785268
    K(1)  = 01001110000010100000010011010010 = 1309279442
          =(1836785268 + 1309279442) Mod 2 ^ 32 = 3146064710
          = 10111011100001010010001101000110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1011 = 11 --> SBOX(0) --> 12 = 1100
    1011 = 11 --> SBOX(1) --> 1 = 0001
    1000 = 8 --> SBOX(2) --> 14 = 1110
    0101 = 5 --> SBOX(3) --> 8 = 1000
    0010 = 2 --> SBOX(4) --> 7 = 0111
    0011 = 3 --> SBOX(5) --> 0 = 0000
    0100 = 4 --> SBOX(6) --> 3 = 0011
    0110 = 6 --> SBOX(7) --> 10 = 1010

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11000001111010000111000000111010
    Setelah Rotate Left Shift: 01000011100000011101011000001111

 5. Lakukan proses XOR pada R(1) dan L(1) untuk mendapatkan
    R(2), R(2) = R(1) XOR L(1):
    ---------------------------------------------------------
    R(1) = 01000011100000011101011000001111
    L(1) = 00001110101101101111011011010010
           ---------------------------------- XOR
    R(2) = 01001101001101110010000011011101

 6. Untuk mendapatkan L(2), nilai R(1) diambil sebelum proses
    L(2) = R(1) sebelum proses:
    -----------------------------------------------------------
    L(2) = 01101101011110110001111001110100





Enkripsi putaran ke-2:
 -----------------------
 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(2) = 01101101011110110001111001110100
    R(2) = 01001101001101110010000011011101

 2. 32 bit bagian kanan, R(2) ditambah dengan upa-kunci K(2)
    modulus 2^32, R(2) + K(2) Mod 2^32:
    ---------------------------------------------------------
    R(2) = 01001101001101110010000011011101 = 1295458525
    K(2)  = 11001110101001100110011011110110 = 3467011830
          =(1295458525 + 3467011830) Mod 2 ^ 32 = 467503059
          = 00011011110111011000011111010011

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0001 = 1 --> SBOX(0) --> 10 = 1010
    1011 = 11 --> SBOX(1) --> 1 = 0001
    1101 = 13 --> SBOX(2) --> 0 = 0000
    1101 = 13 --> SBOX(3) --> 2 = 0010
    1000 = 8 --> SBOX(4) --> 4 = 0100
    0111 = 7 --> SBOX(5) --> 13 = 1101
    1101 = 13 --> SBOX(6) --> 8 = 1000
    0011 = 3 --> SBOX(7) --> 0 = 0000


 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10100001000000100100110110000000
    Setelah Rotate Left Shift: 00010010011011000000010100001000

 5. Lakukan proses XOR pada R(2) dan L(2) untuk mendapatkan
    R(3), R(3) = R(2) XOR L(2):
    ---------------------------------------------------------
    R(2) = 00010010011011000000010100001000
    L(2) = 01101101011110110001111001110100
           ---------------------------------- XOR
    R(3) = 01111111000101110001101101111100

 6. Untuk mendapatkan L(3), nilai R(2) diambil sebelum proses
    L(3) = R(2) sebelum proses:
    -----------------------------------------------------------
    L(3) = 01001101001101110010000011011101

 Enkripsi putaran ke-3:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(3) = 01001101001101110010000011011101
    R(3) = 01111111000101110001101101111100

 2. 32 bit bagian kanan, R(3) ditambah dengan upa-kunci K(3)
    modulus 2^32, R(3) + K(3) Mod 2^32:
    ---------------------------------------------------------
    R(3) = 01111111000101110001101101111100 = 2132220796
    K(3)  = 10000110011101101111011010010110 = 2255943318
          =(2132220796 + 2255943318) Mod 2 ^ 32 = 93196818
          = 00000101100011100001001000010010

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0000 = 0 --> SBOX(0) --> 4 = 0100
    0101 = 5 --> SBOX(1) --> 13 = 1101
    1000 = 8 --> SBOX(2) --> 14 = 1110
    1110 = 14 --> SBOX(3) --> 5 = 0101
    0001 = 1 --> SBOX(4) --> 12 = 1100
    0010 = 2 --> SBOX(5) --> 10 = 1010
    0001 = 1 --> SBOX(6) --> 11 = 1011
    0010 = 2 --> SBOX(7) --> 13 = 1101

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01001101111001011100101010111101
    Setelah Rotate Left Shift: 00101110010101011110101001101111

 5. Lakukan proses XOR pada R(3) dan L(3) untuk mendapatkan
    R(4), R(4) = R(3) XOR L(3):
    ---------------------------------------------------------
    R(3) = 00101110010101011110101001101111
    L(3) = 01001101001101110010000011011101
           ---------------------------------- XOR
    R(4) = 01100011011000101100101010110010

 6. Untuk mendapatkan L(4), nilai R(3) diambil sebelum proses
    L(4) = R(3) sebelum proses:
    -----------------------------------------------------------
    L(4) = 01111111000101110001101101111100












 Enkripsi putaran ke-4:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(4) = 01111111000101110001101101111100
    R(4) = 01100011011000101100101010110010

 2. 32 bit bagian kanan, R(4) ditambah dengan upa-kunci K(4)
    modulus 2^32, R(4) + K(4) Mod 2^32:
    ---------------------------------------------------------
    R(4) = 01100011011000101100101010110010 = 1667418802
    K(4)  = 10000110101100100000010000110110 = 2259813430
          =(1667418802 + 2259813430) Mod 2 ^ 32 = 3927232232
          = 11101010000101001100111011101000

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1110 = 14 --> SBOX(0) --> 5 = 0101
    1010 = 10 --> SBOX(1) --> 8 = 1000
    0001 = 1 --> SBOX(2) --> 8 = 1000
    0100 = 4 --> SBOX(3) --> 0 = 0000
    1100 = 12 --> SBOX(4) --> 0 = 0000
    1110 = 14 --> SBOX(5) --> 15 = 1111
    1110 = 14 --> SBOX(6) --> 2 = 0010
    1000 = 8 --> SBOX(7) --> 9 = 1001

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01011000100000000000111100101001
    Setelah Rotate Left Shift: 00000000011110010100101011000100

 5. Lakukan proses XOR pada R(4) dan L(4) untuk mendapatkan
    R(5), R(5) = R(4) XOR L(4):
    ---------------------------------------------------------
    R(4) = 00000000011110010100101011000100
    L(4) = 01111111000101110001101101111100
           ---------------------------------- XOR
    R(5) = 01111111011011100101000110111000

 6. Untuk mendapatkan L(5), nilai R(4) diambil sebelum proses
    L(5) = R(4) sebelum proses:
    -----------------------------------------------------------
    L(5) = 01100011011000101100101010110010

 Enkripsi putaran ke-5:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(5) = 01100011011000101100101010110010
    R(5) = 01111111011011100101000110111000

 2. 32 bit bagian kanan, R(5) ditambah dengan upa-kunci K(5)
    modulus 2^32, R(5) + K(5) Mod 2^32:
    ---------------------------------------------------------
    R(5) = 01111111011011100101000110111000 = 2137936312
    K(5)  = 11001110110011101000011011010110 = 3469641430
          =(2137936312 + 3469641430) Mod 2 ^ 32 = 1312610446
          = 01001110001111001101100010001110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0100 = 4 --> SBOX(0) --> 13 = 1101
    1110 = 14 --> SBOX(1) --> 5 = 0101
    0011 = 3 --> SBOX(2) --> 13 = 1101
    1100 = 12 --> SBOX(3) --> 11 = 1011
    1101 = 13 --> SBOX(4) --> 3 = 0011
    1000 = 8 --> SBOX(5) --> 3 = 0011
    1000 = 8 --> SBOX(6) --> 0 = 0000
    1110 = 14 --> SBOX(7) --> 8 = 1000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11010101110110110011001100001000
    Setelah Rotate Left Shift: 11011001100110000100011010101110

 5. Lakukan proses XOR pada R(5) dan L(5) untuk mendapatkan
    R(6), R(6) = R(5) XOR L(5):
    ---------------------------------------------------------
    R(5) = 11011001100110000100011010101110
    L(5) = 01100011011000101100101010110010
           ---------------------------------- XOR
    R(6) = 10111010111110101000110000011100

 6. Untuk mendapatkan L(6), nilai R(5) diambil sebelum proses
    L(6) = R(5) sebelum proses:
    -----------------------------------------------------------
    L(6) = 01111111011011100101000110111000

 Enkripsi putaran ke-6:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(6) = 01111111011011100101000110111000
    R(6) = 10111010111110101000110000011100

 2. 32 bit bagian kanan, R(6) ditambah dengan upa-kunci K(6)
    modulus 2^32, R(6) + K(6) Mod 2^32:
    ---------------------------------------------------------
    R(6) = 10111010111110101000110000011100 = 3136982044
    K(6)  = 00000100001101000100111010000110 = 70536838
          =(3136982044 + 70536838) Mod 2 ^ 32 = 3207518882
          = 10111111001011101101101010100010

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1011 = 11 --> SBOX(0) --> 12 = 1100
    1111 = 15 --> SBOX(1) --> 9 = 1001
    0010 = 2 --> SBOX(2) --> 1 = 0001
    1110 = 14 --> SBOX(3) --> 5 = 0101
    1101 = 13 --> SBOX(4) --> 3 = 0011
    1010 = 10 --> SBOX(5) --> 8 = 1000
    1010 = 10 --> SBOX(6) --> 14 = 1110
    0010 = 2 --> SBOX(7) --> 13 = 1101

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11001001000101010011100011101101
    Setelah Rotate Left Shift: 10101001110001110110111001001000

 5. Lakukan proses XOR pada R(6) dan L(6) untuk mendapatkan
    R(7), R(7) = R(6) XOR L(6):
    ---------------------------------------------------------
    R(6) = 10101001110001110110111001001000
    L(6) = 01111111011011100101000110111000
           ---------------------------------- XOR
    R(7) = 11010110101010010011111111110000

 6. Untuk mendapatkan L(7), nilai R(6) diambil sebelum proses
    L(7) = R(6) sebelum proses:
    -----------------------------------------------------------
    L(7) = 10111010111110101000110000011100

 Enkripsi putaran ke-7:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(7) = 10111010111110101000110000011100
    R(7) = 11010110101010010011111111110000

 2. 32 bit bagian kanan, R(7) ditambah dengan upa-kunci K(7)
    modulus 2^32, R(7) + K(7) Mod 2^32:
    ---------------------------------------------------------
    R(7) = 11010110101010010011111111110000 = 3601416176
    K(7)  = 01001100100011000000110001001100 = 1284246604
          =(3601416176 + 1284246604) Mod 2 ^ 32 = 590695484
          = 00100011001101010100110000111100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0010 = 2 --> SBOX(0) --> 9 = 1001
    0011 = 3 --> SBOX(1) --> 12 = 1100
    0011 = 3 --> SBOX(2) --> 13 = 1101
    0101 = 5 --> SBOX(3) --> 8 = 1000
    0100 = 4 --> SBOX(4) --> 5 = 0101
    1100 = 12 --> SBOX(5) --> 9 = 1001
    0011 = 3 --> SBOX(6) --> 1 = 0001
    1100 = 12 --> SBOX(7) --> 6 = 0110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10011100110110000101100100010110
    Setelah Rotate Left Shift: 11000010110010001011010011100110

 5. Lakukan proses XOR pada R(7) dan L(7) untuk mendapatkan
    R(8), R(8) = R(7) XOR L(7):
    ---------------------------------------------------------
    R(7) = 11000010110010001011010011100110
    L(7) = 10111010111110101000110000011100
           ---------------------------------- XOR
    R(8) = 01111000001100100011100011111010

 6. Untuk mendapatkan L(8), nilai R(7) diambil sebelum proses
    L(8) = R(7) sebelum proses:
    -----------------------------------------------------------
    L(8) = 11010110101010010011111111110000

 Enkripsi putaran ke-8:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(8) = 11010110101010010011111111110000
    R(8) = 01111000001100100011100011111010

 2. 32 bit bagian kanan, R(8) ditambah dengan upa-kunci K(0)
    modulus 2^32, R(8) + K(0) Mod 2^32:
    ---------------------------------------------------------
    R(8) = 01111000001100100011100011111010 = 2016557306
    K(0)  = 10010010101100100010101011001010 = 2461149898
          =(2016557306 + 2461149898) Mod 2 ^ 32 = 182739908
          = 00001010111001000110001111000100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0000 = 0 --> SBOX(0) --> 4 = 0100
    1010 = 10 --> SBOX(1) --> 8 = 1000
    1110 = 14 --> SBOX(2) --> 9 = 1001
    0100 = 4 --> SBOX(3) --> 0 = 0000
    0110 = 6 --> SBOX(4) --> 13 = 1101
    0011 = 3 --> SBOX(5) --> 0 = 0000
    1100 = 12 --> SBOX(6) --> 6 = 0110
    0100 = 4 --> SBOX(7) --> 5 = 0101

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01001000100100001101000001100101
    Setelah Rotate Left Shift: 10000110100000110010101001000100

 5. Lakukan proses XOR pada R(8) dan L(8) untuk mendapatkan
    R(9), R(9) = R(8) XOR L(8):
    ---------------------------------------------------------
    R(8) = 10000110100000110010101001000100
    L(8) = 11010110101010010011111111110000
           ---------------------------------- XOR
    R(9) = 01010000001010100001010110110100

 6. Untuk mendapatkan L(9), nilai R(8) diambil sebelum proses
    L(9) = R(8) sebelum proses:
    -----------------------------------------------------------
    L(9) = 01111000001100100011100011111010

 Enkripsi putaran ke-9:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(9) = 01111000001100100011100011111010
    R(9) = 01010000001010100001010110110100

 2. 32 bit bagian kanan, R(9) ditambah dengan upa-kunci K(1)
    modulus 2^32, R(9) + K(1) Mod 2^32:
    ---------------------------------------------------------
    R(9) = 01010000001010100001010110110100 = 1344935348
    K(1)  = 01001110000010100000010011010010 = 1309279442
          =(1344935348 + 1309279442) Mod 2 ^ 32 = 2654214790
          = 10011110001101000001101010000110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1001 = 9 --> SBOX(0) --> 11 = 1011
    1110 = 14 --> SBOX(1) --> 5 = 0101
    0011 = 3 --> SBOX(2) --> 13 = 1101
    0100 = 4 --> SBOX(3) --> 0 = 0000
    0001 = 1 --> SBOX(4) --> 12 = 1100
    1010 = 10 --> SBOX(5) --> 8 = 1000
    1000 = 8 --> SBOX(6) --> 0 = 0000
    0110 = 6 --> SBOX(7) --> 10 = 1010

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10110101110100001100100000001010
    Setelah Rotate Left Shift: 10000110010000000101010110101110

 5. Lakukan proses XOR pada R(9) dan L(9) untuk mendapatkan
    R(10), R(10) = R(9) XOR L(9):
    ---------------------------------------------------------
    R(9) = 10000110010000000101010110101110
    L(9) = 01111000001100100011100011111010
           ---------------------------------- XOR
    R(10) = 11111110011100100110110101010100

 6. Untuk mendapatkan L(10), nilai R(9) diambil sebelum proses
    L(10) = R(9) sebelum proses:
    -----------------------------------------------------------
    L(10) = 01010000001010100001010110110100

 Enkripsi putaran ke-10:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(10) = 01010000001010100001010110110100
    R(10) = 11111110011100100110110101010100

 2. 32 bit bagian kanan, R(10) ditambah dengan upa-kunci K(2)
    modulus 2^32, R(10) + K(2) Mod 2^32:
    ---------------------------------------------------------
    R(10) = 11111110011100100110110101010100 = 4268911956
    K(2)  = 11001110101001100110011011110110 = 3467011830
          =(4268911956 + 3467011830) Mod 2 ^ 32 = 3440956490
          = 11001101000110001101010001001010

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1100 = 12 --> SBOX(0) --> 7 = 0111
    1101 = 13 --> SBOX(1) --> 7 = 0111
    0001 = 1 --> SBOX(2) --> 8 = 1000
    1000 = 8 --> SBOX(3) --> 14 = 1110
    1101 = 13 --> SBOX(4) --> 3 = 0011
    0100 = 4 --> SBOX(5) --> 7 = 0111
    0100 = 4 --> SBOX(6) --> 3 = 0011
    1010 = 10 --> SBOX(7) --> 3 = 0011

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01110111100011100011011100110011
    Setelah Rotate Left Shift: 01110001101110011001101110111100

 5. Lakukan proses XOR pada R(10) dan L(10) untuk mendapatkan
    R(11), R(11) = R(10) XOR L(10):
    ---------------------------------------------------------
    R(10) = 01110001101110011001101110111100
    L(10) = 01010000001010100001010110110100
           ---------------------------------- XOR
    R(11) = 00100001100100111000111000001000

 6. Untuk mendapatkan L(11), nilai R(10) diambil sebelum proses
    L(11) = R(10) sebelum proses:
    -----------------------------------------------------------
    L(11) = 11111110011100100110110101010100

 Enkripsi putaran ke-11:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(11) = 11111110011100100110110101010100
    R(11) = 00100001100100111000111000001000

 2. 32 bit bagian kanan, R(11) ditambah dengan upa-kunci K(3)
    modulus 2^32, R(11) + K(3) Mod 2^32:
    ---------------------------------------------------------
    R(11) = 00100001100100111000111000001000 = 563318280
    K(3)  = 10000110011101101111011010010110 = 2255943318
          =(563318280 + 2255943318) Mod 2 ^ 32 = 2819261598
          = 10101000000010101000010010011110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1010 = 10 --> SBOX(0) --> 1 = 0001
    1000 = 8 --> SBOX(1) --> 2 = 0010
    0000 = 0 --> SBOX(2) --> 5 = 0101
    1010 = 10 --> SBOX(3) --> 6 = 0110
    1000 = 8 --> SBOX(4) --> 4 = 0100
    0100 = 4 --> SBOX(5) --> 7 = 0111
    1001 = 9 --> SBOX(6) --> 10 = 1010
    1110 = 14 --> SBOX(7) --> 8 = 1000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 00010010010101100100011110101000
    Setelah Rotate Left Shift: 10110010001111010100000010010010

 5. Lakukan proses XOR pada R(11) dan L(11) untuk mendapatkan
    R(12), R(12) = R(11) XOR L(11):
    ---------------------------------------------------------
    R(11) = 10110010001111010100000010010010
    L(11) = 11111110011100100110110101010100
           ---------------------------------- XOR
    R(12) = 01001100010011110010110111000110

 6. Untuk mendapatkan L(12), nilai R(11) diambil sebelum proses
    L(12) = R(11) sebelum proses:
    -----------------------------------------------------------
    L(12) = 00100001100100111000111000001000

 Enkripsi putaran ke-12:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(12) = 00100001100100111000111000001000
    R(12) = 01001100010011110010110111000110

 2. 32 bit bagian kanan, R(12) ditambah dengan upa-kunci K(4)
    modulus 2^32, R(12) + K(4) Mod 2^32:
    ---------------------------------------------------------
    R(12) = 01001100010011110010110111000110 = 1280257478
    K(4)  = 10000110101100100000010000110110 = 2259813430
          =(1280257478 + 2259813430) Mod 2 ^ 32 = 3540070908
          = 11010011000000010011000111111100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1101 = 13 --> SBOX(0) --> 15 = 1111
    0011 = 3 --> SBOX(1) --> 12 = 1100
    0000 = 0 --> SBOX(2) --> 5 = 0101
    0001 = 1 --> SBOX(3) --> 13 = 1101
    0011 = 3 --> SBOX(4) --> 1 = 0001
    0001 = 1 --> SBOX(5) --> 11 = 1011
    1111 = 15 --> SBOX(6) --> 12 = 1100
    1100 = 12 --> SBOX(7) --> 6 = 0110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11111100010111010001101111000110
    Setelah Rotate Left Shift: 11101000110111100011011111100010

 5. Lakukan proses XOR pada R(12) dan L(12) untuk mendapatkan
    R(13), R(13) = R(12) XOR L(12):
    ---------------------------------------------------------
    R(12) = 11101000110111100011011111100010
    L(12) = 00100001100100111000111000001000
           ---------------------------------- XOR
    R(13) = 11001001010011011011100111101010

 6. Untuk mendapatkan L(13), nilai R(12) diambil sebelum proses
    L(13) = R(12) sebelum proses:
    -----------------------------------------------------------
    L(13) = 01001100010011110010110111000110

 Enkripsi putaran ke-13:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(13) = 01001100010011110010110111000110
    R(13) = 11001001010011011011100111101010

 2. 32 bit bagian kanan, R(13) ditambah dengan upa-kunci K(5)
    modulus 2^32, R(13) + K(5) Mod 2^32:
    ---------------------------------------------------------
    R(13) = 11001001010011011011100111101010 = 3377314282
    K(5)  = 11001110110011101000011011010110 = 3469641430
          =(3377314282 + 3469641430) Mod 2 ^ 32 = 2551988416
          = 10011000000111000100000011000000

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1001 = 9 --> SBOX(0) --> 11 = 1011
    1000 = 8 --> SBOX(1) --> 2 = 0010
    0001 = 1 --> SBOX(2) --> 8 = 1000
    1100 = 12 --> SBOX(3) --> 11 = 1011
    0100 = 4 --> SBOX(4) --> 5 = 0101
    0000 = 0 --> SBOX(5) --> 4 = 0100
    1100 = 12 --> SBOX(6) --> 6 = 0110
    0000 = 0 --> SBOX(7) --> 1 = 0001

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10110010100010110101010001100001
    Setelah Rotate Left Shift: 01011010101000110000110110010100

 5. Lakukan proses XOR pada R(13) dan L(13) untuk mendapatkan
    R(14), R(14) = R(13) XOR L(13):
    ---------------------------------------------------------
    R(13) = 01011010101000110000110110010100
    L(13) = 01001100010011110010110111000110
           ---------------------------------- XOR
    R(14) = 00010110111011000010000001010010

 6. Untuk mendapatkan L(14), nilai R(13) diambil sebelum proses
    L(14) = R(13) sebelum proses:
    -----------------------------------------------------------
    L(14) = 11001001010011011011100111101010

 Enkripsi putaran ke-14:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(14) = 11001001010011011011100111101010
    R(14) = 00010110111011000010000001010010

 2. 32 bit bagian kanan, R(14) ditambah dengan upa-kunci K(6)
    modulus 2^32, R(14) + K(6) Mod 2^32:
    ---------------------------------------------------------
    R(14) = 00010110111011000010000001010010 = 384573522
    K(6)  = 00000100001101000100111010000110 = 70536838
          =(384573522 + 70536838) Mod 2 ^ 32 = 455110360
          = 00011011001000000110111011011000

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0001 = 1 --> SBOX(0) --> 10 = 1010
    1011 = 11 --> SBOX(1) --> 1 = 0001
    0010 = 2 --> SBOX(2) --> 1 = 0001
    0000 = 0 --> SBOX(3) --> 7 = 0111
    0110 = 6 --> SBOX(4) --> 13 = 1101
    1110 = 14 --> SBOX(5) --> 15 = 1111
    1101 = 13 --> SBOX(6) --> 8 = 1000
    1000 = 8 --> SBOX(7) --> 9 = 1001

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10100001000101111101111110001001
    Setelah Rotate Left Shift: 10111110111111000100110100001000

 5. Lakukan proses XOR pada R(14) dan L(14) untuk mendapatkan
    R(15), R(15) = R(14) XOR L(14):
    ---------------------------------------------------------
    R(14) = 10111110111111000100110100001000
    L(14) = 11001001010011011011100111101010
           ---------------------------------- XOR
    R(15) = 01110111101100011111010011100010

 6. Untuk mendapatkan L(15), nilai R(14) diambil sebelum proses
    L(15) = R(14) sebelum proses:
    -----------------------------------------------------------
    L(15) = 00010110111011000010000001010010

 Enkripsi putaran ke-15:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(15) = 00010110111011000010000001010010
    R(15) = 01110111101100011111010011100010

 2. 32 bit bagian kanan, R(15) ditambah dengan upa-kunci K(7)
    modulus 2^32, R(15) + K(7) Mod 2^32:
    ---------------------------------------------------------
    R(15) = 01110111101100011111010011100010 = 2008151266
    K(7)  = 01001100100011000000110001001100 = 1284246604
          =(2008151266 + 1284246604) Mod 2 ^ 32 = 3292397870
          = 11000100001111100000000100101110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1100 = 12 --> SBOX(0) --> 7 = 0111
    0100 = 4 --> SBOX(1) --> 6 = 0110
    0011 = 3 --> SBOX(2) --> 13 = 1101
    1110 = 14 --> SBOX(3) --> 5 = 0101
    0000 = 0 --> SBOX(4) --> 6 = 0110
    0001 = 1 --> SBOX(5) --> 11 = 1011
    0010 = 2 --> SBOX(6) --> 4 = 0100
    1110 = 14 --> SBOX(7) --> 8 = 1000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01110110110101010110101101001000
    Setelah Rotate Left Shift: 10101011010110100100001110110110

 5. Lakukan proses XOR pada R(15) dan L(15) untuk mendapatkan
    R(16), R(16) = R(15) XOR L(15):
    ---------------------------------------------------------
    R(15) = 10101011010110100100001110110110
    L(15) = 00010110111011000010000001010010
           ---------------------------------- XOR
    R(16) = 10111101101101100110001111100100

 6. Untuk mendapatkan L(16), nilai R(15) diambil sebelum proses
    L(16) = R(15) sebelum proses:
    -----------------------------------------------------------
    L(16) = 01110111101100011111010011100010

 Enkripsi putaran ke-16:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(16) = 01110111101100011111010011100010
    R(16) = 10111101101101100110001111100100

 2. 32 bit bagian kanan, R(16) ditambah dengan upa-kunci K(0)
    modulus 2^32, R(16) + K(0) Mod 2^32:
    ---------------------------------------------------------
    R(16) = 10111101101101100110001111100100 = 3182846948
    K(0)  = 10010010101100100010101011001010 = 2461149898
          =(3182846948 + 2461149898) Mod 2 ^ 32 = 1349029550
          = 01010000011010001000111010101110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0101 = 5 --> SBOX(0) --> 8 = 1000
    0000 = 0 --> SBOX(1) --> 14 = 1110
    0110 = 6 --> SBOX(2) --> 4 = 0100
    1000 = 8 --> SBOX(3) --> 14 = 1110
    1000 = 8 --> SBOX(4) --> 4 = 0100
    1110 = 14 --> SBOX(5) --> 15 = 1111
    1010 = 10 --> SBOX(6) --> 14 = 1110
    1110 = 14 --> SBOX(7) --> 8 = 1000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10001110010011100100111111101000
    Setelah Rotate Left Shift: 01110010011111110100010001110010

 5. Lakukan proses XOR pada R(16) dan L(16) untuk mendapatkan
    R(17), R(17) = R(16) XOR L(16):
    ---------------------------------------------------------
    R(16) = 01110010011111110100010001110010
    L(16) = 01110111101100011111010011100010
           ---------------------------------- XOR
    R(17) = 00000101110011101011000010010000

 6. Untuk mendapatkan L(17), nilai R(16) diambil sebelum proses
    L(17) = R(16) sebelum proses:
    -----------------------------------------------------------
    L(17) = 10111101101101100110001111100100

 Enkripsi putaran ke-17:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(17) = 10111101101101100110001111100100
    R(17) = 00000101110011101011000010010000

 2. 32 bit bagian kanan, R(17) ditambah dengan upa-kunci K(1)
    modulus 2^32, R(17) + K(1) Mod 2^32:
    ---------------------------------------------------------
    R(17) = 00000101110011101011000010010000 = 97431696
    K(1)  = 01001110000010100000010011010010 = 1309279442
          =(97431696 + 1309279442) Mod 2 ^ 32 = 1406711138
          = 01010011110110001011010101100010

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0101 = 5 --> SBOX(0) --> 8 = 1000
    0011 = 3 --> SBOX(1) --> 12 = 1100
    1101 = 13 --> SBOX(2) --> 0 = 0000
    1000 = 8 --> SBOX(3) --> 14 = 1110
    1011 = 11 --> SBOX(4) --> 14 = 1110
    0101 = 5 --> SBOX(5) --> 2 = 0010
    0110 = 6 --> SBOX(6) --> 5 = 0101
    0010 = 2 --> SBOX(7) --> 13 = 1101

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10001100000011101110001001011101
    Setelah Rotate Left Shift: 01110111000100101110110001100000

 5. Lakukan proses XOR pada R(17) dan L(17) untuk mendapatkan
    R(18), R(18) = R(17) XOR L(17):
    ---------------------------------------------------------
    R(17) = 01110111000100101110110001100000
    L(17) = 10111101101101100110001111100100
           ---------------------------------- XOR
    R(18) = 11001010101001001000111110000100

 6. Untuk mendapatkan L(18), nilai R(17) diambil sebelum proses
    L(18) = R(17) sebelum proses:
    -----------------------------------------------------------
    L(18) = 00000101110011101011000010010000

 Enkripsi putaran ke-18:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(18) = 00000101110011101011000010010000
    R(18) = 11001010101001001000111110000100

 2. 32 bit bagian kanan, R(18) ditambah dengan upa-kunci K(2)
    modulus 2^32, R(18) + K(2) Mod 2^32:
    ---------------------------------------------------------
    R(18) = 11001010101001001000111110000100 = 3399782276
    K(2)  = 11001110101001100110011011110110 = 3467011830
          =(3399782276 + 3467011830) Mod 2 ^ 32 = 2571826810
          = 10011001010010101111011001111010

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1001 = 9 --> SBOX(0) --> 11 = 1011
    1001 = 9 --> SBOX(1) --> 3 = 0011
    0100 = 4 --> SBOX(2) --> 10 = 1010
    1010 = 10 --> SBOX(3) --> 6 = 0110
    1111 = 15 --> SBOX(4) --> 2 = 0010
    0110 = 6 --> SBOX(5) --> 1 = 0001
    0111 = 7 --> SBOX(6) --> 9 = 1001
    1010 = 10 --> SBOX(7) --> 3 = 0011

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10110011101001100010000110010011
    Setelah Rotate Left Shift: 00110001000011001001110110011101

 5. Lakukan proses XOR pada R(18) dan L(18) untuk mendapatkan
    R(19), R(19) = R(18) XOR L(18):
    ---------------------------------------------------------
    R(18) = 00110001000011001001110110011101
    L(18) = 00000101110011101011000010010000
           ---------------------------------- XOR
    R(19) = 00110100110000100010110100001101

 6. Untuk mendapatkan L(19), nilai R(18) diambil sebelum proses
    L(19) = R(18) sebelum proses:
    -----------------------------------------------------------
    L(19) = 11001010101001001000111110000100

 Enkripsi putaran ke-19:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(19) = 11001010101001001000111110000100
    R(19) = 00110100110000100010110100001101

 2. 32 bit bagian kanan, R(19) ditambah dengan upa-kunci K(3)
    modulus 2^32, R(19) + K(3) Mod 2^32:
    ---------------------------------------------------------
    R(19) = 00110100110000100010110100001101 = 885140749
    K(3)  = 10000110011101101111011010010110 = 2255943318
          =(885140749 + 2255943318) Mod 2 ^ 32 = 3141084067
          = 10111011001110010010001110100011

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1011 = 11 --> SBOX(0) --> 12 = 1100
    1011 = 11 --> SBOX(1) --> 1 = 0001
    0011 = 3 --> SBOX(2) --> 13 = 1101
    1001 = 9 --> SBOX(3) --> 4 = 0100
    0010 = 2 --> SBOX(4) --> 7 = 0111
    0011 = 3 --> SBOX(5) --> 0 = 0000
    1010 = 10 --> SBOX(6) --> 14 = 1110
    0011 = 3 --> SBOX(7) --> 0 = 0000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11000001110101000111000011100000
    Setelah Rotate Left Shift: 10100011100001110000011000001110

 5. Lakukan proses XOR pada R(19) dan L(19) untuk mendapatkan
    R(20), R(20) = R(19) XOR L(19):
    ---------------------------------------------------------
    R(19) = 10100011100001110000011000001110
    L(19) = 11001010101001001000111110000100
           ---------------------------------- XOR
    R(20) = 01101001001000111000100110001010

 6. Untuk mendapatkan L(20), nilai R(19) diambil sebelum proses
    L(20) = R(19) sebelum proses:
    -----------------------------------------------------------
    L(20) = 00110100110000100010110100001101

 Enkripsi putaran ke-20:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(20) = 00110100110000100010110100001101
    R(20) = 01101001001000111000100110001010

 2. 32 bit bagian kanan, R(20) ditambah dengan upa-kunci K(4)
    modulus 2^32, R(20) + K(4) Mod 2^32:
    ---------------------------------------------------------
    R(20) = 01101001001000111000100110001010 = 1763936650
    K(4)  = 10000110101100100000010000110110 = 2259813430
          =(1763936650 + 2259813430) Mod 2 ^ 32 = 4023750080
          = 11101111110101011000110111000000

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1110 = 14 --> SBOX(0) --> 5 = 0101
    1111 = 15 --> SBOX(1) --> 9 = 1001
    1101 = 13 --> SBOX(2) --> 0 = 0000
    0101 = 5 --> SBOX(3) --> 8 = 1000
    1000 = 8 --> SBOX(4) --> 4 = 0100
    1101 = 13 --> SBOX(5) --> 12 = 1100
    1100 = 12 --> SBOX(6) --> 6 = 0110
    0000 = 0 --> SBOX(7) --> 1 = 0001

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01011001000010000100110001100001
    Setelah Rotate Left Shift: 01000010011000110000101011001000

 5. Lakukan proses XOR pada R(20) dan L(20) untuk mendapatkan
    R(21), R(21) = R(20) XOR L(20):
    ---------------------------------------------------------
    R(20) = 01000010011000110000101011001000
    L(20) = 00110100110000100010110100001101
           ---------------------------------- XOR
    R(21) = 01110110101000010010011111000101

 6. Untuk mendapatkan L(21), nilai R(20) diambil sebelum proses
    L(21) = R(20) sebelum proses:
    -----------------------------------------------------------
    L(21) = 01101001001000111000100110001010

 Enkripsi putaran ke-21:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(21) = 01101001001000111000100110001010
    R(21) = 01110110101000010010011111000101

 2. 32 bit bagian kanan, R(21) ditambah dengan upa-kunci K(5)
    modulus 2^32, R(21) + K(5) Mod 2^32:
    ---------------------------------------------------------
    R(21) = 01110110101000010010011111000101 = 1990272965
    K(5)  = 11001110110011101000011011010110 = 3469641430
          =(1990272965 + 3469641430) Mod 2 ^ 32 = 1164947099
          = 01000101011011111010111010011011

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0100 = 4 --> SBOX(0) --> 13 = 1101
    0101 = 5 --> SBOX(1) --> 13 = 1101
    0110 = 6 --> SBOX(2) --> 4 = 0100
    1111 = 15 --> SBOX(3) --> 3 = 0011
    1010 = 10 --> SBOX(4) --> 9 = 1001
    1110 = 14 --> SBOX(5) --> 15 = 1111
    1001 = 9 --> SBOX(6) --> 10 = 1010
    1011 = 11 --> SBOX(7) --> 14 = 1110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11011101010000111001111110101110
    Setelah Rotate Left Shift: 00011100111111010111011011101010

 5. Lakukan proses XOR pada R(21) dan L(21) untuk mendapatkan
    R(22), R(22) = R(21) XOR L(21):
    ---------------------------------------------------------
    R(21) = 00011100111111010111011011101010
    L(21) = 01101001001000111000100110001010
           ---------------------------------- XOR
    R(22) = 01110101110111101111111101100000

 6. Untuk mendapatkan L(22), nilai R(21) diambil sebelum proses
    L(22) = R(21) sebelum proses:
    -----------------------------------------------------------
    L(22) = 01110110101000010010011111000101

 Enkripsi putaran ke-22:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(22) = 01110110101000010010011111000101
    R(22) = 01110101110111101111111101100000

 2. 32 bit bagian kanan, R(22) ditambah dengan upa-kunci K(6)
    modulus 2^32, R(22) + K(6) Mod 2^32:
    ---------------------------------------------------------
    R(22) = 01110101110111101111111101100000 = 1977548640
    K(6)  = 00000100001101000100111010000110 = 70536838
          =(1977548640 + 70536838) Mod 2 ^ 32 = 2048085478
          = 01111010000100110100110111100110

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0111 = 7 --> SBOX(0) --> 14 = 1110
    1010 = 10 --> SBOX(1) --> 8 = 1000
    0001 = 1 --> SBOX(2) --> 8 = 1000
    0011 = 3 --> SBOX(3) --> 1 = 0001
    0100 = 4 --> SBOX(4) --> 5 = 0101
    1101 = 13 --> SBOX(5) --> 12 = 1100
    1110 = 14 --> SBOX(6) --> 2 = 0010
    0110 = 6 --> SBOX(7) --> 10 = 1010

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11101000100000010101110000101010
    Setelah Rotate Left Shift: 00001010111000010101011101000100

 5. Lakukan proses XOR pada R(22) dan L(22) untuk mendapatkan
    R(23), R(23) = R(22) XOR L(22):
    ---------------------------------------------------------
    R(22) = 00001010111000010101011101000100
    L(22) = 01110110101000010010011111000101
           ---------------------------------- XOR
    R(23) = 01111100010000000111000010000001

 6. Untuk mendapatkan L(23), nilai R(22) diambil sebelum proses
    L(23) = R(22) sebelum proses:
    -----------------------------------------------------------
    L(23) = 01110101110111101111111101100000

 Enkripsi putaran ke-23:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(23) = 01110101110111101111111101100000
    R(23) = 01111100010000000111000010000001

 2. 32 bit bagian kanan, R(23) ditambah dengan upa-kunci K(7)
    modulus 2^32, R(23) + K(7) Mod 2^32:
    ---------------------------------------------------------
    R(23) = 01111100010000000111000010000001 = 2084597889
    K(7)  = 01001100100011000000110001001100 = 1284246604
          =(2084597889 + 1284246604) Mod 2 ^ 32 = 3368844493
          = 11001000110011000111110011001101

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1100 = 12 --> SBOX(0) --> 7 = 0111
    1000 = 8 --> SBOX(1) --> 2 = 0010
    1100 = 12 --> SBOX(2) --> 6 = 0110
    1100 = 12 --> SBOX(3) --> 11 = 1011
    0111 = 7 --> SBOX(4) --> 8 = 1000
    1100 = 12 --> SBOX(5) --> 9 = 1001
    1100 = 12 --> SBOX(6) --> 6 = 0110
    1101 = 13 --> SBOX(7) --> 11 = 1011

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01110010011010111000100101101011
    Setelah Rotate Left Shift: 01011100010010110101101110010011

 5. Lakukan proses XOR pada R(23) dan L(23) untuk mendapatkan
    R(24), R(24) = R(23) XOR L(23):
    ---------------------------------------------------------
    R(23) = 01011100010010110101101110010011
    L(23) = 01110101110111101111111101100000
           ---------------------------------- XOR
    R(24) = 00101001100101011010010011110011

 6. Untuk mendapatkan L(24), nilai R(23) diambil sebelum proses
    L(24) = R(23) sebelum proses:
    -----------------------------------------------------------
    L(24) = 01111100010000000111000010000001

 Enkripsi putaran ke-24:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(24) = 01111100010000000111000010000001
    R(24) = 00101001100101011010010011110011

 2. 32 bit bagian kanan, R(24) ditambah dengan upa-kunci K(7)
    modulus 2^32, R(24) + K(7) Mod 2^32:
    ---------------------------------------------------------
    R(24) = 00101001100101011010010011110011 = 697672947
    K(7)  = 01001100100011000000110001001100 = 1284246604
          =(697672947 + 1284246604) Mod 2 ^ 32 = 1981919551
          = 01110110001000011011000100111111

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0111 = 7 --> SBOX(0) --> 14 = 1110
    0110 = 6 --> SBOX(1) --> 15 = 1111
    0010 = 2 --> SBOX(2) --> 1 = 0001
    0001 = 1 --> SBOX(3) --> 13 = 1101
    1011 = 11 --> SBOX(4) --> 14 = 1110
    0001 = 1 --> SBOX(5) --> 11 = 1011
    0011 = 3 --> SBOX(6) --> 1 = 0001
    1111 = 15 --> SBOX(7) --> 12 = 1100

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11101111000111011110101100011100
    Setelah Rotate Left Shift: 11101111010110001110011101111000

 5. Lakukan proses XOR pada R(24) dan L(24) untuk mendapatkan
    R(25), R(25) = R(24) XOR L(24):
    ---------------------------------------------------------
    R(24) = 11101111010110001110011101111000
    L(24) = 01111100010000000111000010000001
           ---------------------------------- XOR
    R(25) = 10010011000110001001011111111001

 6. Untuk mendapatkan L(25), nilai R(24) diambil sebelum proses
    L(25) = R(24) sebelum proses:
    -----------------------------------------------------------
    L(25) = 00101001100101011010010011110011

 Enkripsi putaran ke-25:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(25) = 00101001100101011010010011110011
    R(25) = 10010011000110001001011111111001

 2. 32 bit bagian kanan, R(25) ditambah dengan upa-kunci K(6)
    modulus 2^32, R(25) + K(6) Mod 2^32:
    ---------------------------------------------------------
    R(25) = 10010011000110001001011111111001 = 2467862521
    K(6)  = 00000100001101000100111010000110 = 70536838
          =(2467862521 + 70536838) Mod 2 ^ 32 = 2538399359
          = 10010111010011001110011001111111

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1001 = 9 --> SBOX(0) --> 11 = 1011
    0111 = 7 --> SBOX(1) --> 10 = 1010
    0100 = 4 --> SBOX(2) --> 10 = 1010
    1100 = 12 --> SBOX(3) --> 11 = 1011
    1110 = 14 --> SBOX(4) --> 11 = 1011
    0110 = 6 --> SBOX(5) --> 1 = 0001
    0111 = 7 --> SBOX(6) --> 9 = 1001
    1111 = 15 --> SBOX(7) --> 12 = 1100

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 10111010101010111011000110011100
    Setelah Rotate Left Shift: 01011101100011001110010111010101

 5. Lakukan proses XOR pada R(25) dan L(25) untuk mendapatkan
    R(26), R(26) = R(25) XOR L(25):
    ---------------------------------------------------------
    R(25) = 01011101100011001110010111010101
    L(25) = 00101001100101011010010011110011
           ---------------------------------- XOR
    R(26) = 01110100000110010100000100100110

 6. Untuk mendapatkan L(26), nilai R(25) diambil sebelum proses
    L(26) = R(25) sebelum proses:
    -----------------------------------------------------------
    L(26) = 10010011000110001001011111111001

 Enkripsi putaran ke-26:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(26) = 10010011000110001001011111111001
    R(26) = 01110100000110010100000100100110

 2. 32 bit bagian kanan, R(26) ditambah dengan upa-kunci K(5)
    modulus 2^32, R(26) + K(5) Mod 2^32:
    ---------------------------------------------------------
    R(26) = 01110100000110010100000100100110 = 1947812134
    K(5)  = 11001110110011101000011011010110 = 3469641430
          =(1947812134 + 3469641430) Mod 2 ^ 32 = 1122486268
          = 01000010111001111100011111111100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0100 = 4 --> SBOX(0) --> 13 = 1101
    0010 = 2 --> SBOX(1) --> 4 = 0100
    1110 = 14 --> SBOX(2) --> 9 = 1001
    0111 = 7 --> SBOX(3) --> 15 = 1111
    1100 = 12 --> SBOX(4) --> 0 = 0000
    0111 = 7 --> SBOX(5) --> 13 = 1101
    1111 = 15 --> SBOX(6) --> 12 = 1100
    1100 = 12 --> SBOX(7) --> 6 = 0110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11010100100111110000110111000110
    Setelah Rotate Left Shift: 11111000011011100011011010100100

 5. Lakukan proses XOR pada R(26) dan L(26) untuk mendapatkan
    R(27), R(27) = R(26) XOR L(26):
    ---------------------------------------------------------
    R(26) = 11111000011011100011011010100100
    L(26) = 10010011000110001001011111111001
           ---------------------------------- XOR
    R(27) = 01101011011101101010000101011101

 6. Untuk mendapatkan L(27), nilai R(26) diambil sebelum proses
    L(27) = R(26) sebelum proses:
    -----------------------------------------------------------
    L(27) = 01110100000110010100000100100110

 Enkripsi putaran ke-27:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(27) = 01110100000110010100000100100110
    R(27) = 01101011011101101010000101011101

 2. 32 bit bagian kanan, R(27) ditambah dengan upa-kunci K(4)
    modulus 2^32, R(27) + K(4) Mod 2^32:
    ---------------------------------------------------------
    R(27) = 01101011011101101010000101011101 = 1802936669
    K(4)  = 10000110101100100000010000110110 = 2259813430
          =(1802936669 + 2259813430) Mod 2 ^ 32 = 4062750099
          = 11110010001010001010010110010011

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1111 = 15 --> SBOX(0) --> 3 = 0011
    0010 = 2 --> SBOX(1) --> 4 = 0100
    0010 = 2 --> SBOX(2) --> 1 = 0001
    1000 = 8 --> SBOX(3) --> 14 = 1110
    1010 = 10 --> SBOX(4) --> 9 = 1001
    0101 = 5 --> SBOX(5) --> 2 = 0010
    1001 = 9 --> SBOX(6) --> 10 = 1010
    0011 = 3 --> SBOX(7) --> 0 = 0000

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 00110100000111101001001010100000
    Setelah Rotate Left Shift: 11110100100101010000000110100000

 5. Lakukan proses XOR pada R(27) dan L(27) untuk mendapatkan
    R(28), R(28) = R(27) XOR L(27):
    ---------------------------------------------------------
    R(27) = 11110100100101010000000110100000
    L(27) = 01110100000110010100000100100110
           ---------------------------------- XOR
    R(28) = 10000000100011000100000010000110

 6. Untuk mendapatkan L(28), nilai R(27) diambil sebelum proses
    L(28) = R(27) sebelum proses:
    -----------------------------------------------------------
    L(28) = 01101011011101101010000101011101

 Enkripsi putaran ke-28:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(28) = 01101011011101101010000101011101
    R(28) = 10000000100011000100000010000110

 2. 32 bit bagian kanan, R(28) ditambah dengan upa-kunci K(3)
    modulus 2^32, R(28) + K(3) Mod 2^32:
    ---------------------------------------------------------
    R(28) = 10000000100011000100000010000110 = 2156675206
    K(3)  = 10000110011101101111011010010110 = 2255943318
          =(2156675206 + 2255943318) Mod 2 ^ 32 = 117651228
          = 00000111000000110011011100011100

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0000 = 0 --> SBOX(0) --> 4 = 0100
    0111 = 7 --> SBOX(1) --> 10 = 1010
    0000 = 0 --> SBOX(2) --> 5 = 0101
    0011 = 3 --> SBOX(3) --> 1 = 0001
    0011 = 3 --> SBOX(4) --> 1 = 0001
    0111 = 7 --> SBOX(5) --> 13 = 1101
    0001 = 1 --> SBOX(6) --> 11 = 1011
    1100 = 12 --> SBOX(7) --> 6 = 0110

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 01001010010100010001110110110110
    Setelah Rotate Left Shift: 10001000111011011011001001010010

 5. Lakukan proses XOR pada R(28) dan L(28) untuk mendapatkan
    R(29), R(29) = R(28) XOR L(28):
    ---------------------------------------------------------
    R(28) = 10001000111011011011001001010010
    L(28) = 01101011011101101010000101011101
           ---------------------------------- XOR
    R(29) = 11100011100110110001001100001111

 6. Untuk mendapatkan L(29), nilai R(28) diambil sebelum proses
    L(29) = R(28) sebelum proses:
    -----------------------------------------------------------
    L(29) = 10000000100011000100000010000110

 Enkripsi putaran ke-29:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(29) = 10000000100011000100000010000110
    R(29) = 11100011100110110001001100001111

 2. 32 bit bagian kanan, R(29) ditambah dengan upa-kunci K(2)
    modulus 2^32, R(29) + K(2) Mod 2^32:
    ---------------------------------------------------------
    R(29) = 11100011100110110001001100001111 = 3818590991
    K(2)  = 11001110101001100110011011110110 = 3467011830
          =(3818590991 + 3467011830) Mod 2 ^ 32 = 2990635525
          = 10110010010000010111101000000101

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    1011 = 11 --> SBOX(0) --> 12 = 1100
    0010 = 2 --> SBOX(1) --> 4 = 0100
    0100 = 4 --> SBOX(2) --> 10 = 1010
    0001 = 1 --> SBOX(3) --> 13 = 1101
    0111 = 7 --> SBOX(4) --> 8 = 1000
    1010 = 10 --> SBOX(5) --> 8 = 1000
    0000 = 0 --> SBOX(6) --> 13 = 1101
    0101 = 5 --> SBOX(7) --> 7 = 0111

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 11000100101011011000100011010111
    Setelah Rotate Left Shift: 01101100010001101011111000100101

 5. Lakukan proses XOR pada R(29) dan L(29) untuk mendapatkan
    R(30), R(30) = R(29) XOR L(29):
    ---------------------------------------------------------
    R(29) = 01101100010001101011111000100101
    L(29) = 10000000100011000100000010000110
           ---------------------------------- XOR
    R(30) = 11101100110010101111111010100011

 6. Untuk mendapatkan L(30), nilai R(29) diambil sebelum proses
    L(30) = R(29) sebelum proses:
    -----------------------------------------------------------
    L(30) = 11100011100110110001001100001111

 Enkripsi putaran ke-30:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(30) = 11100011100110110001001100001111
    R(30) = 11101100110010101111111010100011

 2. 32 bit bagian kanan, R(30) ditambah dengan upa-kunci K(1)
    modulus 2^32, R(30) + K(1) Mod 2^32:
    ---------------------------------------------------------
    R(30) = 11101100110010101111111010100011 = 3972726435
    K(1)  = 01001110000010100000010011010010 = 1309279442
          =(3972726435 + 1309279442) Mod 2 ^ 32 = 987038581
          = 00111010110101010000001101110101

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0011 = 3 --> SBOX(0) --> 2 = 0010
    1010 = 10 --> SBOX(1) --> 8 = 1000
    1101 = 13 --> SBOX(2) --> 0 = 0000
    0101 = 5 --> SBOX(3) --> 8 = 1000
    0000 = 0 --> SBOX(4) --> 6 = 0110
    0011 = 3 --> SBOX(5) --> 0 = 0000
    0111 = 7 --> SBOX(6) --> 9 = 1001
    0101 = 5 --> SBOX(7) --> 7 = 0111

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 00101000000010000110000010010111
    Setelah Rotate Left Shift: 01000011000001001011100101000000

 5. Lakukan proses XOR pada R(30) dan L(30) untuk mendapatkan
    R(31), R(31) = R(30) XOR L(30):
    ---------------------------------------------------------
    R(30) = 01000011000001001011100101000000
    L(30) = 11100011100110110001001100001111
           ---------------------------------- XOR
    R(31) = 10100000100111111010101001001111

 6. Untuk mendapatkan L(31), nilai R(30) diambil sebelum proses
    L(31) = R(30) sebelum proses:
    -----------------------------------------------------------
    L(31) = 11101100110010101111111010100011

 Enkripsi putaran ke-31:
 -----------------------

 1. Nilai biner 64 bit dipecah menjadi 32 bit bagian kiri, L dan
    32 bit bagian kanan, R:
    ------------------------------------------------------------
    L(31) = 11101100110010101111111010100011
    R(31) = 10100000100111111010101001001111

 2. 32 bit bagian kanan, R(31) ditambah dengan upa-kunci K(0)
    modulus 2^32, R(31) + K(0) Mod 2^32:
    ---------------------------------------------------------
    R(31) = 10100000100111111010101001001111 = 2694818383
    K(0)  = 10010010101100100010101011001010 = 2461149898
          =(2694818383 + 2461149898) Mod 2 ^ 32 = 861000985
          = 00110011010100011101010100011001

 3. Hasil biner 32 bit dipecah menjadi 8 kelompok masing-masing
    4 bit dan masukkan ke tabel SBox:
    -----------------------------------------------------------
    0011 = 3 --> SBOX(0) --> 2 = 0010
    0011 = 3 --> SBOX(1) --> 12 = 1100
    0101 = 5 --> SBOX(2) --> 3 = 0011
    0001 = 1 --> SBOX(3) --> 13 = 1101
    1101 = 13 --> SBOX(4) --> 3 = 0011
    0101 = 5 --> SBOX(5) --> 2 = 0010
    0001 = 1 --> SBOX(6) --> 11 = 1011
    1001 = 9 --> SBOX(7) --> 2 = 0010

 4. Hasil nilai biner keluaran dari tabel SBox digabungkan
    kembali dan lakukan Rotate Left Shift sebanyak 11 kali:
    -------------------------------------------------------
    Hasil penggabungan: 00101100001111010011001010110010
    Setelah Rotate Left Shift: 11101001100101011001000101100001

 5. Lakukan proses XOR pada R(31) dan L(31) untuk mendapatkan
    R(32), R(32) = R(31) XOR L(31):
    ---------------------------------------------------------
    R(31) = 11101001100101011001000101100001
    L(31) = 11101100110010101111111010100011
           ---------------------------------- XOR
    R(32) = 10100000100111111010101001001111

 6. Untuk mendapatkan L(32), nilai R(31) diambil sebelum proses
    L(32) = R(31) sebelum proses:
    -----------------------------------------------------------
    L(32) = 00000101010111110110111111000010

 7. Lakukan pembalikan string untuk nilai R(32) dan L(32):
    ------------------------------------------------------
    R(32) = 10100000100111111010101001001111
    L(32) = 00000101010111110110111111000010

    setelah dilakukan pembalikan string, menjadi:

    R(32) = 11110010010101011111100100000101
    L(32) = 01000011111101101111101010100000

 8. Gabung nilai R(32) dan L(32) untuk mendapatkan nilai
    biner 64 bit, Biner(64 bit) = R(32) dan L(32):
    ----------------------------------------------------
    1111001001010101111110010000010101000011111101101111101010100000

 9. Hasil biner 64 bit dipecah menjadi 8 kelompok masing-masing
    8 bit dan konversi ke nilai ASCII:
    -----------------------------------------------------------
    11110010 = 'ò'
    01010101 = 'U'
    11111001 = 'ù'
    00000101 = ''
    01000011 = 'C'
    11110110 = 'ö'
    11111010 = 'ú'
    10100000 = ' '

 Hasil enkripsi yang didapatkan adalah:
 --------------------------------------
 'òUùCöú '

Diposting oleh di
Label:

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)