**S-DES or Simplified Data Encryption Standard**

The process of encrypting a plan text into an encrypted message with the use of S-DES has been divided into multi-steps which may help you to understand it as easily as possible.

Points should be remembered.

- It is a block cipher.
- It has 8-bits block size of plain text or cipher text.
- It uses 10-bits key size for encryption.
- It is a symmetric cipher.
- It has Two Rounds.

Let’s start the game!

**Key Generation of S-DES or How to Generate the Key of Simplified DES**

First and foremost, we need to generate a key. With the help of this key we will encrypt the message.

Now the interesting question is, how to generate the key, and where the key is to be used. Just follow the steps.

Now the interesting question is, how to generate the key, and where the key is to be used. Just follow the steps.

Step 1:

Step 1:

Just select a random key of 10-bits, which only should be shared between both parties which means sender and receiver.

As I selected below!

Select key:1010000010

**Note:Y**ou can select any random number of 10-bits.

Step 2:

Step 2:

Put this key into P.10 Table and permute the bits.

**P.10 Table:**

Input | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

Output Should be | 3 | 5 | 2 | 7 | 4 | 10 | 1 | 9 | 8 | 6 |

As I put key into P.10 Table.

Input | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |

Output | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |

Now the output will be:

Key: 1000001100

Step 3:

Step 3:

Divide the key into two halves, left half and right half;

{1 0 0 0 0} | {0 1 1 0 0}

Step 4:

Step 4:

Now apply the one bit Round shift on each half:

Before round shift: {10000} | {01100}

After round shift: {00001} | {11000}

The output will be:

{0 0 0 0 1} {1 1 0 0 0}

Step 5:

Step 5:

Now once again combine both halve of the bits, right and left. Put them into the P8 table. What you get, that will be the K1 or First key.

Combine: 0 0 0 0 1 1 1 0 0 0

**Permute into 8bit table:**

P8-Table

Input | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

Combine-bits | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 |

Output Should be | 6 | 3 | 7 | 4 | 8 | 5 | 10 | 9 | ||

Output bits | 1 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |

See the table the 1 and 2 number of bits are removed and other are permuted, as 6 in place of one, 9 in place of 8 and so on.

**The output and K1 or key One will be:**

K1=1 0 1 0 0 1 0 0

Step6:

Step6:

As we know S-DES has two round and for that

**we also need two keys**, one key we generate in the above steps (step 1 to step 5). Now we need to

**generate a second**bit and after that we will move to encrypt the plain text or message.

It is simple to generate the second key. Simply, go in

**step 4**copy both halves, each one consists of 5 bits. But be careful on the taking of bits. Select those halves which are output of first round shift, don’t take the bits which are not used in the first round. In simple words, take the output of first round shift in above

**step 4.**

Which are: {00001} | {11000}

Step 7:

Step 7:

Now just apply two round shift circulate on each half of the bits, which means to change the position of two bits of each halves.

left half: 00001

Right half: 11000

After the two rounds shift on each half out-put of each half will be.

**Left half:**00100

**Right half:**00011

Combine both together: As: 0 0 1 0 0 – 0 0 0 1 1

Step 8:

Step 8:

Now put the bits into 8-P Table, what you get, that will be your second key. Table is also given in

**step 5**.

But here the combinations of bits are changed because of two left round shift from step 5. Check it in depth.

Combine bits: 0 0 1 0 0 0 0 0 1 1

P.8 Table

P.8 Table

Input | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

Combine-bits | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |

Output Should be | 6 | 3 | 7 | 4 | 8 | 5 | 10 | 9 | ||

Output bits | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 |

The output of the bits are your Second key or K2:

K2: 0 1 0 0 0 0 1 1

Finally we create both keys successfully:

K1: 1 0 1 0 0 1 0 0 (see in step 5)

K2: 0 1 0 0 0 0 1 1 (see in step 8)

**
How To Encrypt the Plain Text into Cipher Text in S-DES After Generating Keys.**

Now, let’s start Encryption of plain text into cipher text.

**Encryption of Plain text into Cipher text in S-DES:**

Come on do it,

**step by step**.**Note:**the size of input text is 8 bit and output also will be 8-bit. Or the block size is 8-bit/one byte always.

Step 1:

Step 1:

Suppose this is our plain text in binary which is 8-bit.

Plain text: 01110010

Plain text: 01110010

Step 2:

Step 2:

Put the plain text into IP-8(initial permutation) table and permute the bits.

IP-8 table

IP-8 table

Bits number | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

Bits to be permuted | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 |

Permute the bits | 2 | 6 | 3 | 1 | 4 | 8 | 5 | 7 |

Permuted bits | 1 | 0 | 1 | 0 | 1 | 0 | 0 | 1 |

Output is: 1 0 1 0 1 0 0 1

Step 3:

Step 3:

Now break the bits into two halves, each half will consist of 4 bits. The halves will be right and left.

Two Halves of the bits:

Left half {1 0 1 0} -right half {1 0 0 1}

Step 4:

Step 4:

Take the right 4 bits and put them into E.P (expand and per-mutate) Table.

Bits of right half: 1001

E.P Table

E.P Table

Right half bits | 1 | 0 | 0 | 0 | ||||

Number | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

Expand bits | 4 | 1 | 2 | 3 | 2 | 3 | 4 | 1 |

Output of bits | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |

Output of right four bits will be 8 bits, after their expanding with the help of E.P table.

**: 0 1 0 0 0 0 0 1**

O-P

O-P

**Now, just take the output and XOR it with First key Or K 1 (which we created in previous topic that is how to generate key.).**

Step 5:

Step 5:

XOR (⊕) them:

XOR (⊕) them:

**: 0 1 0 0 0 0 0 1**

O-p

O-p

**⊕**

**K1**:

__1 0 1 0 0 1 0 0__

Output of XOR:

**1 1 1 0 0101**

Step 6:

Step 6:

Once again split the output of XOR’s bit into two halves and each half will consist of 4 bits.

**Splitting them into two halves:**

Left half :{ 1 1 1 0} right half :{ 0101}

Now put the each half into the

**s-boxes**, there is only two s-boxes.**S-0 and S-1.**

S-0

S-0

Col | 0 | 1 | 2 | 3 |

Rows | ||||

0 | 01 | 00 | 11 | 10 |

1 | 11 | 10 | 01 | 00 |

2 | 00 | 10 | 01 | 11 |

3 | 11 | 01 | 11 | 10 |

**S-1**

Col | 0 | 1 | 2 | 3 |

Rows | ||||

0 | 00 | 01 | 10 | 11 |

1 | 10 | 00 | 01 | 11 |

2 | 11 | 00 | 01 | 00 |

3 | 10 | 01 | 00 | 11 |

Note: put the left half into S-0 box and put the right half into S-1 Box.

**But how to put them in into S-Boxes?**

Take any half, (but don’t forget the above mentioned note..).

The most first and most last bit will be consider the row and other remaining, which are, 2 and 3, will be considered the columns.

See, here I’m taking the left half: which is 1 1 1 0.

Now I will take First and last bit which are: 1 and 0. These will be row.

And I also will take 2

^{nd}and 3

^{rd}bits which are: 11. These will be column number.

10 means=2

^{rd}**row**11 means = 3

^{rd}**col**See below how it will be the second row, and 3

^{rd}column. Please, remember the IP Addressing, such as 2

^{8}for 255.

1

^{2 }0^{1}=2+0=21

^{2 }1^{1}=2+1=3Let’s check the 2

^{nd}row and 3

^{rd}column.

For

**left half**we check the in S

**-0**. In which 2

^{nd}row and 3

^{rd}column.

The output is 00 for left half;

Now let’s take the

**right half**and find the output of the right of in

**S-1 box**.

Right half: 0101

Row: 0 1= 0

^{2 }1^{1}=0+1=1Col: 1 0=1

^{2 }0^{1}=2+1=3Which means the value will be in 1

^{st}row and 3

^{rd}column, let’s in

**check S-1.**

The output will be: 11 for left half.

Step 7:

Step 7:

Now combine these two halves together.

Left half: {00} and right half: {11}

It will be: 0 0 1 1

**Now take these 4 bits and put them in**

Step 8:

Step 8:

**P-4**(permutation 4) table and get the result.

P 4 Table

P 4 Table

Numbers | 1 | 2 | 3 | 4 |

Input | 0 | 0 | 1 | 1 |

Output should be | 2 | 4 | 3 | 1 |

Out-Put | 0 | 1 | 1 | 0 |

Now the output is: 0 1 1 0

Step 9:

Step 9:

Now get XOR the output with left 4 bits of Initial Per-mutation. The left bits of initial per-mutation are in

**step 3**, which are

**1 0 1 0**.( please, in step 3).

Let them to be XOR.

0 1 1 0

⊕

__1 0 1 0__

Out-put will be: 1 1 0 0

Step 10:

Step 10:

Now get the right half of the initial permutation, which is

**step 3,**and combine that with this out- put.

The out-put of XOR in

**step 9:**1 1 0 0

Right half of IP (initial permutation): 1 0 0 1

Let’s combine both. 1 1 0 0 – 1 0 0 1= 1 1 0 0 1 0 0 1

Now the output is 8 bits.:

**1 1 0 0 1 0 0 1****: Now once again break the out-put into two halves, left and right;**

Step 11

Step 11

Left: {1 1 0 0} right: {1 0 0 1}

Step 12:

Step 12:

Now swap both halves, which means put the left half in place of right and vice versa.

Result:

Result:

Left half: {1 0 0 1} right half: {1 1 0 0}

Step 13:

Step 13:

Now let’s take these halves and once again start the same procedure from

**step 2**or initial Permutation,

**BUT**be careful on using key in this stage we use second key or K2 (not K1). And put that into IP

^{-1 }(IP inverse) Table. What you get will be your final cipher text.

Let me to do it in brief. You should check carefully what I did.

Ø 1 0 0 1 11 0 0

After initial permutation according to

**IP-8 table (see step 2)**

Out-put will be: 0 1 0 1 1 0 1 0

Ø Now break it into two halves

Left {0 1 0 1} right {1 0 1 0}

Ø Now Take the right 4bits and put them into

**EP table**, and get the result of 8 bits.

It will be: 0 1 0 1 0 1 0 1

Ø Let

**XOR it with K2.**

**K2:**0 1 0 0 0 0 1 1

⊕

Out-put of

**EP**:

__0 1 0 1 0 1 0 1__

**Out- Put**:

**0 0 0 1 0 1 1 0**

Ø Once again split the output of XOR’s bit into two halves:

Left: {0 0 0 1} right: {0 1 1 0}

Ø Now put each half in S-Boxes, which are S-0 and S-1:

Note: put the left half into S-0 box and put the right half into S-1 Box.

Note: put the left half into S-0 box and put the right half into S-1 Box.

**Before that get Rows and column:**

Left: 0 0 0 1

Row: 0 1= 1

Col: 0 0 = 0

Let find the row and column of left, in S-0, the value is row number one and col number Zero.

It will be. 1 1

Ø now check the right half: 0 1 1 0

Row: 0 0=0

Col: 1 1= 3

Let's find the row and column of right, in S-1, the value is row number zero and col number three.

It will be: 11

Ø Now combine both halves together.

It will be: 1 1 1 1

Ø Now take these 4 bits and put them in

**P-4**(

**Per**-

**mutation**4) table and get the result.

The out-put also will be: 1111 after permutation.

Ø Now get it XOR with left 4 bits of Initial Per-Mutation.

1 1 1 1

XOR

__0 1 0 1__

**:1 0 1 0**

Out-put

Out-put

Ø Now get the right half of the initial permutation and combine that with this out- put.

1 0 1 0 - 0 1 1 0

Ø Now once again break the it into two halves, left and right

Left: {1 0 1 0} right: {0 1 1 0}

Ø Now

**swap both halves,**which means put the left half in place of right and vice versa.

**0 1 1 0 1 0 1 0**

**Ø**

**Now put it into IP**

^{-1 }Table which is :

IP

IP

^{-1 }TableNumbers | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

input | 0 | 1 | 1 | 0 | 1 | 0 | 1 | 0 |

Out-put to be | 2 | 6 | 3 | 1 | 4 | 8 | 5 | 7 |

Out-Put | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 1 |

**Out-Put is the cipher text. Which is: 1 0 1 0 0 0 1 1**

Finally we Encrypted successfully our

**plain text:**

**01110010**into

**cipher text**which is:

1 0 1 0 0 0 1 1

1 0 1 0 0 0 1 1

*Note: We have encrypted simply a single block.*

You can also find the post in my blog.

Read more articles on

**Cryptography**:Recommended Free Ebook

Similar Articles