NAME: ROLL.

NO:

WORKSHEET DATA ENCRYPTION STANDARD

Example: Find Cipher text for the give plain text M- message

Let:-

M = 01001110 01000101 01010110 01010010 01010001 01010101 01001001 01010100

L
M

Example: Let K be the key K = KASHISAB.

K=01001011 01000001 01010011 01001000 01001001 01010011 01000001 01000010

The DES algorithm uses the following steps:

CREATE 16 SUB KEYS, EACH OF WHICH IS 48-BITS LONG.

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

Example: From the original 64-bit key

K=

K+=

Next, split this key into left and right halves, C0 and D0, where each half has 28 bits.

C0=

D0=
 Iteration Number of
Number Left Shifts
1 1
2 1
3 2
4 2
5 2
6 2
7 2
8 2
9 1
10 2
11 2
12 2
13 2
14 2
15 2
16 1

C1 =
D1 =

C2 =
D2 =

C3 =
D3 =

C4 =
D4 =

C5 =
D5 =

C6 =
D6 =

C7 =
D7 =

C8 =
D8 =
C9
D9 =

C10 =
D10 =

C11 =
D11 =

C12 =
D12 =

C13 =
D13 =

C14 =
D14 =

C15 =
D15 =

C16 =
D16 =
We now form the keys Kn, for 1<=n<=16, by applying the following permutation table to each of the
concatenated pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48 of these.
PC-2
14 17 11 24 1 5
3 28 15 6 21 10
23 19 12 4 26 8
16 7 27 20 13 2
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32

Therefore, the first bit of Kn is the 14th bit of CnDn, the second bit the 17th, and so on, ending with the 48th bit
of Kn being the 32th bit of CnDn.

Example: For the first key we have

C1 =
D1 =

Which after we apply the permutation PC-2, becomes

K1 =

For the other keys we have

K2 =
K3 =
K4 =
K5 =
K6 =
K7 =
K8 =
K9 =
K10 =
K11 =
K12 =
K13 =
K14 =
K15 =
K16 =
ENCRYPTION
There is an initial permutation IP of the 64 bits of the message data M. This rearranges the bits according to the
following table, where the entries in the table show the new arrangement of the bits from their initial order. The
58th bit of M becomes the first bit of IP. The 50th bit of M becomes the second bit of IP. The 7th bit of M is
the last bit of IP.

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

Example: Applying the initial permutation to the block of text M, given previously, we get

M=
IP =

Next divide the permuted block IP into a left half L0 of 32 bits, and a right half R0 of 32 bits.

Example: From IP, we get L0 and R0

L0 =
R0 =

We now proceed through 16 iterations, for 1<=n<=16, using a function f which operates on two blocks--a
data block of 32 bits and a key Kn of 48 bits--to produce a block of 32 bits. Let + denote XOR addition, (bit-
by-bit addition modulo 2). Then for n going from 1 to 16 we calculate

Ln = Rn-1
Rn = Ln-1 + f (Rn-1, Kn)

This results in a final block, for n = 16, of L16R16. That is, in each iteration, we take the right 32 bits of the
previous result and make them the left 32 bits of the current step. For the right 32 bits in the current step, we
XOR the left 32 bits of the previous step with the calculation f.

Example: For n = 1, we have

K1=
L 1 = R0 =
R1 = L0 + f(R0,K1)

It remains to explain how the function f works. To calculate f, we first expand each block Rn-1 from 32 bits to
48 bits. This is done by using a selection table that repeats some of the bits in Rn-1 . We'll call the use of this
selection table the function E. Thus E(Rn-1) has a 32 bit input block, and a 48 bit output block.
Let E be such that the 48 bits of its output, written as 8 blocks of 6 bits each, are obtained by selecting the bits
in its inputs in order according to the following table:
E BIT-SELECTION TABLE
 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

Thus the first three bits of E(Rn-1) are the bits in positions 32, 1 and 2 of Rn-1 while the last 2 bits of E(Rn-1) are
the bits in positions 32 and 1.

Example: We calculate E(R0) from R0 as follows:

R0 =

E(R0) =

(Note that each block of 4 original bits has been expanded to a block of 6 output bits.)

Next in the f calculation, we XOR the output E(Rn-1) with the key Kn:

Kn + E(Rn-1).

Example: For K1 , E(R0), we have

K1 =
E(R0) =
K1+E(R0) =

We have not yet finished calculating the function f . To this point we have expanded Rn-1 from 32 bits to 48 bits,
using the selection table, and XORed the result with the key Kn . We now have 48 bits, or eight groups of six
bits. We now do something strange with each group of six bits: we use them as addresses in tables called " S
boxes". Each group of six bits will give us an address in a different S box. Located at that address will be a 4 bit
number. This 4 bit number will replace the original 6 bits. The net result is that the eight groups of 6 bits are
transformed into eight groups of 4 bits (the 4-bit outputs from the S boxes) for 32 bits total.
Write the previous result, which is 48 bits, in the form:

Kn + E(Rn-1) =B1B2B3B4B5B6B7B8,

where each Bi is a group of six bits. We now calculate

S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8)

where Si(Bi) referres to the output of the i-th S box.

To repeat, each of the functions S1, S2,..., S8, takes a 6-bit block as input and yields a 4-bit block as output. The
table to determine S1 is shown and explained below:
S1

Column Number
Row
No. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
1 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
2 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
3 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13

The tables defining the functions S1,...,S8 are the following:

S1
14 4 1 1 2 15 11 8 3 10 6 12 5 9 0 7
3
0 15 7 4 14 2 13 1 1 6 1 11 9 5 3 8
0 2
4 1 1 8 13 6 2 11 1 12 9 7 3 10 5 0
4 5
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 1 0 1 10 6 9 11 5
2
0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15
13 8 1 1 3 15 4 2 1 6 7 12 0 5 14 9
0 1
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 1 0 6 9 8 7 4 15 14 3 11 5 2 12
3
S4
7 13 1 3 0 6 9 10 1 2 8 5 11 12 4 15
4
 13 8 1 5 6 15 0 3 4 7 2 12 1 10 14 9
1
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 1 7 1 14 2 13 6 15 0 9 10 4 5 3
2
S6
12 1 1 15 9 2 6 8 0 13 3 4 14 7 5 11
0
10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8
9 14 1 5 2 8 12 3 7 0 4 10 1 13 11 6
5
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 1 7 4 9 1 10 14 3 5 12 2 15 8 6
1
1 4 1 13 12 3 7 14 10 15 6 8 0 5 9 2
1
6 11 1 8 1 4 10 7 9 5 0 15 14 2 3 12
3
S8
13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7
1 15 1 8 10 3 7 4 12 5 6 11 0 14 9 2
3
7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8
2 1 1 7 4 10 8 13 15 12 9 0 3 5 6 11
4

Example: For the first round, we obtain as the output of the eight S boxes:

K1 + E(R0) =

S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8) =

The final stage in the calculation of f is to do a permutation P of the S-box output to obtain the final value of f:

f = P(S1(B1)S2(B2)...S8(B8))

The permutation P is defined in the following table. P yields a 32-bit output from a 32-bit input by permuting
the bits of the input block.
 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
19 13 30 6
2 11 4 25

Example: From the output of the eight S boxes:

S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8) =

f= 1101 0011 0000 1001 0111 0110 1101 0001

R1 = L0 + f (R0 , K1 )

=
So now

L1=
R1=

In the next round, we will have L2 = R1, which is the block we just calculated, and then we must calculate R2
=L1 + f(R1, K2), and so on for 16 rounds. At the end of the sixteenth round we have the blocks L16 and R16. We
then reverse the order of the two blocks into the 64-bit block

STEP 2

L2=0010 1100 1011 0101 1101 0001 1010 0011

R2=L1 +f (R1, K2)

f (R1,K2)= 0010 1100 1010 1000 1011 0000 0101 0011

R2=0000 0000 0000 0000 0100 0001 0000 1101

L2=0010 1100 1011 0101 1101 0001 1010 0011

R2=0010 1100 1010 1000 1111 0001 0101 1110

STEP 3
L3=
R3=L2+f(R2, K3)
f(R2, K3)=
R3=
+
=
L3=
R3=
STEP4

L4=

R4=L3+f(R3,K4)

So R4=

STEP5

L5=

R5=L4+f(R4,K5)

So R5=

STEP6

L6=

R6=

L5+f(R5,K6)

So R6=

STEP7

L7=

R7=L6+f(R6,K7)

So R7=

STEP8

L8=

R8=L7+f(R7,K8)

So R8=
STEP 9

L9=

R9=L8+f(R8,K9)

So R9=

STEP10

L10=

R10=L9+f(R9,K10)

So R10=

STEP11

L11=

R11=L10+f(R10,K11)

So R11=

STEP12

L12=
R12=L11+f(R11,K12)

So R12=

STEP13

L13=

R13=L12+f(R12,K13)

So R13=

STEP14

L14=

R14=L13+f(R13,K14)

So R14=
STEP15

L15=

R15=L14+f(R14,K15)

So R15=

STEP16

L16=

R16=L15+f(R15,K16)

S0 R16=

Example: If we process all 16 blocks using the method defined previously, we get, on the 16th round,

L16 =
R16 =
We reverse the order of these two blocks and apply the final permutation to

R16L16 =

and apply a final permutation IP-1 as defined by the following table:

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

IP-1 =

 Hexadecimal format is:

 Cipher Text =