1. Code needs to compile and run on its own.

2. At runtime the program must take an input from the user that indicates ENCRYPTION or DECRYPTION is being performed.

3. After the selection of encryption/decryption , the program must ask for the Plaintext ( in case of Encryption) and Ciphertext ( in case of Decryption).

4. The program then must ask for the Key.

5. The output must be the only thing printed on the screen. Suppress any other outputs.

 

 

ISE334/SE425: E-Commerce, Com., and Info. Security
Semester 2 5774 Recitation 3
12 March 2014 Simplified DES
1 Introduction In this lab we will work through a simplified version of the DES algorithm. The algorithm is not cryptographically secure, but its operations are similar enough to the DES operation to give a better feeling for
how it works.
We will proceed by reading the Simplified DES algorithm description in the Stallings section. We will
then work through a full example in class. 2 Full Example Let the plaintext be the string 0010 1000. Let the 10 bit key be 1100011110. 2.1 Key Generation The keys k1 and k2 are derived using the functions P 10, Shift, and P 8.
P 10 is defined as follows:
5 2 7 4 P10
10 6 3 7 4 P8
8 The first key k1 is therefore equal to:
Bit # 1 2 3 4
K 1 1 0 0
P 10(K) 0 0 1 1
Shif t(P 10(K)) 0 1 1 0
P 8(Shif t(P 10(K))) 1 1 1 0 5
0
0
0
1 6
1
0
1
0 7
1
1
1
0 8
1
1
1
1 3 1 9 8 5 10 9 9
1
1
1 10
0
1
0 6 P 8 is defined to be as follows: The second key k2 is derived in
Bit # 1 2
K 1 1
P 10(K) 0 0
Shif t3 (P 10(K))) 1 0
P 8(Shif t2 (P 10(K))) 1 0 a similar manner:
3 4 5 6 7
0 0 0 1 1
1 1 0 0 1
0 0 1 1 1
1 0 0 1 1 8
1
1
0
1 9
1
1
1 10
0
1
1 So we have the two keys k1 = {1110 1001} and k2 = {1010 0111} 2.2 Initial and Final Permutation The plaintext undergoes an initial permutation when it enters the encryption function, IP . It undergoes a
reverse final permutation at the end IP −1 .
The function IP is defined as follows: 1 IP
2 6 3 1 4 8 5 7 The function IP −1 is defined as follows:
4 1 3 IP −1
5 7 2 Applied to the input,
Bit # 1 2 3
P 0 0 1
IP (P ) 0 0 1 2.3 8
we
4
0
0 6 have the following after the initial permutation:
5 6 7 8
1 0 0 0
0 0 1 0 Functions fK , SW , K • The function fk is defined as follows. Let P = (L, R), then fK (L, R) = (L ⊕ F (R, SK), R).
• The function SW just switches the two halves of the plaintext, so SW (L, R) → (R, L)
• The function F (p, k) takes a four bit string p and eight bit key k and produces a four bit output. It
performs the following steps.
1. First it runs an expansion permutation E/P :
E/P
4 1 2 3 2 3 4 1
2. Then it XORs the key with the result of the E/P function
3. Then it substitutes the two halves based on the S-Boxes.
4. Finally, the output from the S-Boxes undergoes the P 4 permutation: P4
2 4 3 1 Applying the functions, we must perform the following steps: IP −1 ◦ fK2 ◦ SW ◦ fK1 ◦ IP
1. We have already calculated IP (P ) = {0010 0010}. Applying the next functions:
2. fK1 (L, R) = f{1110 1001} (0010 0010) = (0010 ⊕ F (0010, {1110 1001}), 0010) 3. F (0010, {1110 1001}) = P 4 ◦ SBoxes ◦ {1110 1001} ⊕ (E/P (0010))
4. The steps are:
Bit #
R
E/P(R)
k1
E/P(R)⊕k1
SBoxes(E/P(R)⊕k1 )
P4(Sboxes(E/P(R)⊕k1 )) 1
0
0
1
1
1
0 2
0
0
1
1
0
0 3
1
0
1
1
0
0 4
0
1
0
1
0
1 5 6 7 8 0
1
1 1
0
1 0
0
0 0
1
1 5. The result from F is therefore 0001
6. Calculating we then have fk1 (L, R) = (0010 ⊕ 0001, 0010) = (0011, 0010)
7. So far, then L = 0011 and R = 0010. SW just swaps them so R = 0011 and L = 0010.
8. We now do the calculation of fk2 (L, R) = f{1010 0111} (0010 2 0011) = (0010⊕F (0011, {1010 0111}, 0011)) 9. The steps for F are as above:
Bit #
R
E/P(R)
k2
E/P(R)⊕k2
SBoxes(E/P(R)⊕k2 )
P4(Sboxes(E/P(R)⊕k2 )) 1
0
1
1
0
1
0 2
0
0
0
0
0
0 3
1
0
1
1
1
1 4
1
1
0
1
0
1 5 6 7 8 0
0
0 1
1
0 1
1
0 0
1
1 10. So now we have the outcome of F as 0011
11. Calculating we then have fk2 (L, R) = (0010 ⊕ 0011, 0011) = (0001, 0011)
12. Last, we perform the IP −1 permutation:
Bit #
R,L
IP −1 (R,L) 1
0
1 2
0
0 3
0
0 4
1
0 5
0
1 6
0
0 7
1
1 8
1
0 13. So the final result of the encryption is 1000 1010. 3

Attachments:

• 1493452493-SDES Example.pdf