UNIVERSITI KUALA LUMPUR-MIIT

Network Forensic
(INB 35303)
“ Data Encryption Standard (DES) ”

Prepared by:
Name Metric No.:
Amir Helmi bin Hamid 52261207043
Muhammad Afif bin Ahmad 52261207079
Mohd Hasri bin Lockman 52261207194
Mohd Noor Ikmal bin Rasli 52261207061
Azharemy b A.Aziz 52261207073
Muhammad Bukhari Bin Mohammad 52261109150
Kamal

Prepared for: Assoc. Prof Dr. Shahrulniza bin Musa

Date Received: __________________________

Introduction of DES

The Data Encryption Standard (DES) is a block chipper and was developed in
the 1970s by the National Bureau of Standards ( now official Federal Information
Processing Standard (FIPS)) with the help of the National Security Agency. Its
purpose is to provide a standard method for protecting sensitive commercial and
unclassified data. IBM created the first draft of the algorithm, calling it LUCIFER.
DES officially became a federal standard in November of 1976.

DES is a symmetric cryptosystem: when used for communication, both sender

and receiver must know the same secret key, which is used both to encrypt and
decrypt the message. DES can also be used for single-user encryption, such
as to store files on a hard disk in encrypted form. In a multi-user environment,
secure key distribution may be difficult; public-key cryptography provides an ideal
solution to this problem

How DES work

Encryption of a block of the message takes place in 16 stages or rounds.

From the input key, sixteen 48 bit keys are generated, one for each round. In
each round, eight so-called S-boxes are used. These S-boxes are fixed in the
specification of the standard. Using the S-boxes, groups of six bits are mapped
to groups of four bits. The contents of these S-boxes has been determined by
the U.S. National Security Agency (NSA). The S-boxes appear to be randomly
filled, but this is not the case. Recently it has been discovered that these S-
boxes, determined in the 1970s, are resistant against an attack called differential
cryptanalysis which was first known in the 1990s.
The block of the message is divided into two halves. The right half is expanded
from 32 to 48 bits using another fixed table. The result is combined with the
subkey for that round using the XOR operation. Using the S-boxes the 48
resulting bits are then transformed again to 32 bits, which are subsequently
permutated again using yet another fixed table. This by now thoroughly shuffled
right half is now combined with the left half using the XOR operation. In the next
round, this combination is used as the new left half.

The figure should hopefully make this process a bit more clear. In the figure,
the left and right halves are denotes as L0 and R0, and in subsequent rounds
as L1, R1, L2, R2 and so on. The function f is responsible for all the mappings
described above.
Security of DES

This secret key encryption algorithm uses a key that is 56 bits, or seven
characters long. At the time it was believed that trying out all
72,057,594,037,927,936 possible keys (a seven with 16 zeros) would be
impossible because computers could not possibly ever become fast enough. In
1998 the Electronic Frontier Foundation (EFF) built a special-purpose machine
that could decrypt a message by trying out all possible keys in less than three
days. The machine cost less than $250,000 and searched over 88 billion keys
per second.

Triple-DES

The Triple-DES variant was developed after it became clear that DES by itself
was too easy to crack. It uses three 56-bit DES keys, giving a total key length of
168 bits. Encryption using Triple-DES is simply:-
● encryption using DES with the first 56-bit key
● decryption using DES with the second 56-bit key
● encryption using DES with the third 56-bit key
Because Triple-DES applies the DES algorithm three times (hence the name),
Triple-DES takes three times as long as standard DES. Decryption using Triple-
DES is the same as the encryption, except it is executed in reverse.
Algorithm

1 Process the key.

1.1 Get a 64-bit key from the user. (Every 8th bit (the least significant bit of each byte) is
considered a parity bit. For a key to have correct parity, each byte should contain an odd
number of "1" bits). This key can be entered directly, or it can be the result of hashing
something else. There is no standard hashing algorithm for this purpose.

1.2 Calculate the key schedule.

1.2.1 Perform the following permutation on the 64-bit key. (The parity bits are discarded,
reducing the key to 56 bits. Bit 1 (the most significant bit) of the permuted block is bit 57 of the
original key, bit 2 is bit 49, and so on with bit 56 being bit 4 of the original key.)

Permuted Choice 1 (PC-1)

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

1.2.2 Split the permuted key into two halves. The first 28 bits are called C[0] and the last 28
bits are called D[0].

1.2.3 Calculate the 16 subkeys. Start with i = 1.

1.2.3.1 Perform one or two circular left shifts on both C[i-1] and D[i-1] to get C[i] and D[i],
respectively. The number of shifts per iteration are given in the table below.

iteration 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
left shift 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
1.2.3.2 Permute the concatenation C[i]D[i] as indicated below. This will yield K[i], which is 48
bits long.

Permuted Choice 2 (PC-2)

13 16 10 23 0 4
2 27 14 5 20 9
22 18 11 3 25 7
15 6 26 19 12 1
40 51 30 36 46 54
29 39 50 44 32 47
43 48 38 55 33 52
45 41 49 35 28 31

1.2.3.3 Loop back to 1.2.3.1 until K[16] has been calculated.

2 Process a 64-bit data block.

2.1 Get a 64-bit data block. If the block is shorter than 64 bits, it should be padded as
appropriate for the application.

2.2 Perform the following permutation on the data block.

Initial Permutation (IP)

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
56 48 40 32 24 16 8 0
58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6

2.3 Split the block into two halves. The first 32 bits are called
L[0], and the last 32 bits are called R[0].

2.4 Apply the 16 subkeys to the data block. Start with i = 1.

2.4.1 Expand the 32-bit R[i-1] into 48 bits according to the
bit-selection function below.

Expansion (E)

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

2.4.2 Exclusive-or E(R[i-1]) with K[i].

2.4.3 Break E(R[i-1]) xor K[i] into eight 6-bit blocks. Bits 1-6 are
B[1], bits 7-12 are B[2], and so on with bits 43-48 being B[8].

2.4.4 Substitute the values found in the S-boxes for all B[j]. Start
with j = 1. All values in the S-boxes should be considered 4 bits wide.

2.4.4.1 Take the 1st and 6th bits of B[j] together as a 2-bit value
(call it m) indicating the row in S[j] to look in for the substitution.

2.4.4.2 Take the 2nd through 5th bits of B[j] together as a 4-bit
value (call it n) indicating the column in S[j] to find the substitution.

2.4.4.3 Replace B[j] with S[j][m][n].

Substitution Box 1

S[1]
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

S[2]
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
S[3]
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

S[4]
7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15
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

S[5]
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

S[6]
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

S[7]
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

S[8]
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 4 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

2.4.4.4 Loop back to 2.4.4.1 until all 8 blocks have been replaced.
2.4.5 Permute the concatenation of B[1] through B[8] as indicated below.

Permutation P

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

2.4.6 Exclusive-or the resulting value with L[i-1]. Thus, all together,
your R[i] = L[i-1] xor P(S[1](B[1])...S[8](B[8])), where B[j] is a 6-bit
block of E(R[i-1]) xor K[i]. (The function for R[i] is more concisely
written as, R[i] = L[i-1] xor f(R[i-1], K[i]).)

2.4.7 L[i] = R[i-1].

2.4.8 Loop back to 2.4.1 until K[16] has been applied.

2.5 Perform the following permutation on the block R[16]L[16]. (Note

that block R precedes block L this time.)

Final Permutation (IP**-1)

39 7 47 15 55 23 63 31
38 6 46 14 54 23 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
32 0 40 8 48 16 56 24
import sys

# _pythonMajorVersion utk check ver 2 atau 3

_pythonMajorVersion = sys.version_info[0]

# jenis crypting / cyphering

ECB = 0
CBC = 1

# jenis padding
PAD_NORMAL = 1
PAD_PKCS5 = 2

class _DES(object):
def __init__(sendiri, jenis=ECB, IV=None, pad=None, jenispad=PAD_NORMAL):
if IV:
IV = sendiri._tangkapUnicode(IV)
if pad:
pad = sendiri._tangkapUnicode(pad)
sendiri.block_size = 8
# check argumen betul atau tidak.
if pad and jenispad == PAD_PKCS5:
raise ValueError("Tak boleh guna pad char dgn PAD_PKCS5")
if IV and len(IV) != sendiri.block_size:
raise ValueError("Invalid Initial Value (IV), mesti gandaan " + str
(sendiri.block_size) + " bytes")

# Set passed in variable

sendiri._jenis = jenis
sendiri._iv = IV
sendiri._padding = pad
sendiri._jenispad = jenispad

def getKey(sendiri):
return sendiri.__key

def setKey(sendiri, key):

key = sendiri._tangkapUnicode(key)
sendiri.__key = key

def getjenis(sendiri):
return sendiri._jenis

def setjenis(sendiri, jenis):

sendiri._jenis = jenis

def getPadding(sendiri):
return sendiri._padding

def setPadding(sendiri, pad):

if pad is not None:
pad = sendiri._tangkapUnicode(pad)
sendiri._padding = pad

def getjenispad(sendiri):
return sendiri._jenispad

def setjenispad(sendiri, jenis):

sendiri._jenispad = jenis

def getIV(sendiri):
return sendiri._iv

def setIV(sendiri, IV):

if not IV or len(IV) != sendiri.block_size:
raise ValueError("Invalid Initial Value (IV), mesti gandaan " + str
(sendiri.block_size) + " bytes")
 IV = sendiri._tangkapUnicode(IV)
sendiri._iv = IV

def _padData(sendiri, data, pad, jenispad):

# Pad data bergantung pada jenis
if jenispad is None:
# dapatkan jenispad default.
jenispad = sendiri.getjenispad()
if pad and jenispad == PAD_PKCS5:
raise ValueError("Cannot use a pad character with PAD_PKCS5")

if jenispad == PAD_NORMAL:
if len(data) % sendiri.block_size == 0:
# tak perlukan padding.
return data

if not pad:
# dapatkan padding default.
pad = sendiri.getPadding()
if not pad:
raise ValueError("Data mesti gandaan " + str(sendiri.block_size) + "
bytes. Guna jenispad=PAD_PKCS5 atau setkan pad character.")
data += (sendiri.block_size - (len(data) % sendiri.block_size)) * pad

elif jenispad == PAD_PKCS5:

pad_len = 8 - (len(data) % sendiri.block_size)
if _pythonMajorVersion < 3:
data += pad_len * chr(pad_len)
else:
data += bytes([pad_len] * pad_len)

return data

def _unpadData(sendiri, data, pad, jenispad):

# Unpad bergantung pada jenis.
if not data:
return data
if pad and jenispad == PAD_PKCS5:
raise ValueError("Cannot use a pad character with PAD_PKCS5")
if jenispad is None:
# dapatkan jenis default.
jenispad = sendiri.getjenispad()

if jenispad == PAD_NORMAL:
if not pad:
# dapatkan padding default.
pad = sendiri.getPadding()
if pad:
data = data[:-sendiri.block_size] + \
data[-sendiri.block_size:].rstrip(pad)

elif jenispad == PAD_PKCS5:

if _pythonMajorVersion < 3:
pad_len = ord(data[-1])
else:
pad_len = data[-1]
data = data[:-pad_len]

return data

def _tangkapUnicode(sendiri, data):

if _pythonMajorVersion < 3:
if isinstance(data, unicode):
raise ValueError("pyDes can only work with bytes, not Unicode strings.")
else:
if isinstance(data, str):
# Only accept ascii unicode values.
try:
return data.encode('ascii')
except UnicodeEncodeError:
 pass
raise ValueError("pyDes can only work with encoded strings, not Unicode.")
return data

#############################################################################
# DES #
#############################################################################
class des(_DES):

# Permutation 1
__pc1 = [57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 0, 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
]

__left_rotations = [
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
]

# permutation 2
__pc2 = [
13, 16, 10, 23, 0, 4,
2, 27, 14, 5, 20, 9,
22, 18, 11, 3, 25, 7,
15, 6, 26, 19, 12, 1,
40, 51, 30, 36, 46, 54,
29, 39, 50, 44, 32, 47,
43, 48, 38, 55, 33, 52,
45, 41, 49, 35, 28, 31
]

# initial permutation IP
__ip = [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,
56, 48, 40, 32, 24, 16, 8, 0,
58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6
]

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

# Substitution Box
__sbox = [
# 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, 15,
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,
10, 15, 4, 2, 7, 12, 9, 5,
9, 14, 15, 5, 2, 8, 12, 3,
4, 3, 2, 12, 9, 5, 15, 10,
0, 13, 3, 4, 14, 7, 5, 11,
6, 1, 13, 14, 0, 11, 3, 8,
7, 0, 4, 10, 1, 13, 11, 6,
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, 4, 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],
]

# 32-bit permutation utk output lepas S-boxes

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

# final permutation
__fp = [
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,
32, 0, 40, 8, 48, 16, 56, 24
]

ENCRYPT = 0x00
DECRYPT = 0x01
# Initialisation
def __init__(sendiri, key, jenis=ECB, IV=None, pad=None, jenispad=PAD_NORMAL):
if len(key) != 8:
raise ValueError("Invalid DES key size. key mesti 8 byte.")
_DES.__init__(sendiri, jenis, IV, pad, jenispad)
sendiri.key_size = 8

sendiri.L = []
sendiri.R = []
sendiri.Kn = [ [0] * 48 ] * 16 # 16 48-bit keys (K1 - K16)
sendiri.final = []

sendiri.setKey(key)

def setKey(sendiri, key):

_DES.setKey(sendiri, key)
sendiri.__create_sub_keys()

def __String_to_BitList(sendiri, data):

"""tukar string jadi binary bit"""
if _pythonMajorVersion < 3:
data = [ord(c) for c in data]
l = len(data) * 8
result = [0] * l
pos = 0
for ch in data:
i = 7
while i >= 0:
if ch & (1 << i) != 0:
result[pos] = 1
else:
result[pos] = 0
pos += 1
i -= 1

return result

def __BitList_to_String(sendiri, data):

"""tukar bit jadi string"""
result = []
pos = 0
c = 0
while pos < len(data):
c += data[pos] << (7 - (pos % 8))
if (pos % 8) == 7:
result.append(c)
c = 0
pos += 1

if _pythonMajorVersion < 3:
return ''.join([ chr(c) for c in result ])
else:
return bytes(result)

def __permutate(sendiri, table, block):

return list(map(lambda x: block[x], table))

# tukar key kepada 16 sub key

def __create_sub_keys(sendiri):
"""Create the 16 subkeys K[1] to K[16] from the given key"""
key = sendiri.__permutate(des.__pc1, sendiri.__String_to_BitList(sendiri.getKey()))
i = 0
# Split Left and Right
sendiri.L = key[:28]
sendiri.R = key[28:]
while i < 16:
j = 0
# left shifts
while j < des.__left_rotations[i]:
sendiri.L.append(sendiri.L[0])
 del sendiri.L[0]

sendiri.R.append(sendiri.R[0])
del sendiri.R[0]

j += 1

sendiri.Kn[i] = sendiri.__permutate(des.__pc2, sendiri.L + sendiri.R)

i += 1

# Main part
def __des_crypt(sendiri, block, crypt_type):
block = sendiri.__permutate(des.__ip, block)
sendiri.L = block[:32]
sendiri.R = block[32:]

# Encryption dari Kn[1] hingga Kn[16]

if crypt_type == des.ENCRYPT:
iteration = 0
iteration_adjustment = 1
# Decryption dari Kn[16] hingga Kn[1]
else:
iteration = 15
iteration_adjustment = -1

i = 0
while i < 16:
# Make a copy of R[i-1], this will later become L[i]
tempR = sendiri.R[:]

# Permutate R[i - 1] to start creating R[i]

sendiri.R = sendiri.__permutate(des.__expansion_table, sendiri.R)

# Exclusive or R[i - 1] with K[i], create B[1] to B[8] whilst here

sendiri.R = list(map(lambda x, y: x ^ y, sendiri.R, sendiri.Kn[iteration]))
B = [sendiri.R[:6], sendiri.R[6:12], sendiri.R[12:18], sendiri.R[18:24], sendiri.R
[24:30], sendiri.R[30:36], sendiri.R[36:42], sendiri.R[42:]]
j = 0
Bn = [0] * 32
pos = 0
while j < 8:
m = (B[j][0] << 1) + B[j][5]
n = (B[j][1] << 3) + (B[j][2] << 2) + (B[j][3] << 1) + B[j][4]

# cari permutation value

v = des.__sbox[j][(m << 4) + n]

# tukar value ke Binary

Bn[pos] = (v & 8) >> 3
Bn[pos + 1] = (v & 4) >> 2
Bn[pos + 2] = (v & 2) >> 1
Bn[pos + 3] = v & 1

pos += 4
j += 1

sendiri.R = sendiri.__permutate(des.__p, Bn)

# Xor dgn L[i - 1]

sendiri.R = list(map(lambda x, y: x ^ y, sendiri.R, sendiri.L))
sendiri.L = tempR

i += 1
iteration += iteration_adjustment

# Final permutation of R[16]L[16]

sendiri.final = sendiri.__permutate(des.__fp, sendiri.R + sendiri.L)
return sendiri.final
 # Data yang nak encrypted/decrypted
def crypt(sendiri, data, crypt_type):

if not data:
return ''
if len(data) % sendiri.block_size != 0:
if crypt_type == des.DECRYPT:
raise ValueError("Invalid data length, data mesti gandaan " + str
(sendiri.block_size) + " bytes\n.")
if not sendiri.getPadding():
raise ValueError("Invalid data length, data mesti gandaan " + str
(sendiri.block_size) + " bytes\n. cuba padding character")
else:
data += (sendiri.block_size - (len(data) % sendiri.block_size)) *
sendiri.getPadding()

if sendiri.getjenis() == CBC:
if sendiri.getIV():
iv = sendiri.__String_to_BitList(sendiri.getIV())
else:
raise ValueError("untuk CBC, berikan Initial Value (IV) ")

# bahagikan kepada blok crypting masing masing

i = 0
dict = {}
result = []
while i < len(data):
block = sendiri.__String_to_BitList(data[i:i+8])

# Xor dgn IV kalau guna jenis CBC

if sendiri.getjenis() == CBC:
if crypt_type == des.ENCRYPT:
block = list(map(lambda x, y: x ^ y, block, iv))

processed_block = sendiri.__des_crypt(block, crypt_type)

if crypt_type == des.DECRYPT:
processed_block = list(map(lambda x, y: x ^ y, processed_block,
iv))
iv = block
else:
iv = processed_block
else:
processed_block = sendiri.__des_crypt(block, crypt_type)

result.append(sendiri.__BitList_to_String(processed_block))
i += 8

if _pythonMajorVersion < 3:
return ''.join(result)
else:
return bytes.fromhex('').join(result)

def encrypt(sendiri, data, pad=None, jenispad=None):

data = sendiri._tangkapUnicode(data)
if pad is not None:
pad = sendiri._tangkapUnicode(pad)
data = sendiri._padData(data, pad, jenispad)
return sendiri.crypt(data, des.ENCRYPT)

def decrypt(sendiri, data, pad=None, jenispad=None):

data = sendiri._tangkapUnicode(data)
if pad is not None:
pad = sendiri._tangkapUnicode(pad)
data = sendiri.crypt(data, des.DECRYPT)
return sendiri._unpadData(data, pad, jenispad)