Simplified Data Encryption Standard | Set 2

22 Oct, 2021
Prerequisite – Simplified Data Encryption Standard | Set 1
Simplified Data Encryption Standard is a simple version of Data Encryption Standard having a 10-bit key and 8-bit plain text. It is much smaller than the DES algorithm as it takes only 8-bit plain text whereas DES takes 64-bit plain text. It was developed for educational purpose so that understanding DES can become easy. It is a block cipher algorithm and uses a symmetric key for its algorithm i.e. they use the same key for both encryption and decryption. It has 2 rounds for encryption which use two different keys. 
First, we need to generate 2 keys before encryption. After generating keys we pass them to each individual round for s-des encryption. The below diagram shows the steps involved in the s-des algorithm.
Components :S-DES encryption involves four functions –
1. Initial permutation(IP) –
2. Complex function (fk) –It is the combination of permutation and substitution functions. The below image represents a round of encryption and decryption. This round is repeated twice in each encryption and decryption.  
Components in fk are –a. Expanded Permutation (EP) – It takes a 4-bit input and converts it into an 8-bit output. 
       b. S-boxes (S0 and S1) –It is a basic component of a symmetric key algorithm that performs substitution. 
       c. Permutation P4 –
3. Switch (SW) – 
4. Inverse of Initial Permutation (IP-1) –
First, we need to generate 2 keys before encryption. 
Consider, the entered 10-bit key is - 1 0 1 0 0 0 0 0 1 0
Therefore,
Key-1 is - 1 0 1 0 0 1 0 0
Key-2 is - 0 1 0 0 0 0 1 1
Entered 8-bit plaintext is - 1 0 0 1 0 1 1 1
Step-1:We perform initial permutation on our 8-bit plain text using the IP table. The initial permutation is defined as – 
IP(k1, k2, k3, k4, k5, k6, k7, k8) = (k2, k6, k3, k1, k4, k8, k5, k7)
After ip = 0 1 0 1 1 1 0 1
Step-2:After the initial permutation, we get an 8-bit block of text which we divide into 2 halves of 4 bit each.
l = 0 1 0 1  and r = 1 1 0 1
On the right half, we perform expanded permutation using EP table which converts 4 bits into 8 bits. Expand permutation is defined as – 
EP(k1, k2, k3, k4) = (k4, k1, k2, k3, k2, k3, k4, k1)
After ep = 1 1 1 0 1 0 1 1
We perform XOR operation using the first key K1 with the output of expanded permutation.
Key-1 is - 1 0 1 0 0 1 0 0
(1 0 1 0 0 1 0 0) XOR (1 1 1 0 1 0 1 1) =  0 1 0 0 1 1 1 1
After XOR operation with 1st Key = 0 1 0 0 1 1 1 1
Again we divide the output of XOR into 2 halves of 4 bit each.
l = 0 1 0 0  and r = 1 1 1 1
We take the first and fourth bit as row and the second and third bit as a column for our S boxes.
S0 = [1,0,3,2
      3,2,1,0
      0,2,1,3
      3,1,3,2]

S1=  [0,1,2,3
      2,0,1,3
      3,0,1,0
      2,1,0,3]

For l = 0 1 0 0
row = 00 = 0, column = 10 = 2
S0 = 3 = 11

For r = 1 1 1 1 
row = 11 = 3, column = 11 = 3
S1 = 3 = 11

After first S-Boxes combining S0 and S1 = 1 1 1 1
S boxes gives a 2-bit output which we combine to get 4 bits and then perform permutation using the P4 table. P4 is defined as – 
P4(k1, k2, k3, k4) = (k2, k4, k3, k1)
After P4 = 1 1 1 1
We XOR the output of the P4 table with the left half of the initial permutation table i.e. IP table.
(0 1 0 1) XOR (1 1 1 1) = 1 0 1 0
After XOR operation with left nibble of after ip = 1 0 1 0
We combine both halves i.e. right half of initial permutation and output of ip.
Combine 1 1 0 1 and 1 0 1 0
After combine = 1 0 1 0 1 1 0 1
Step-3:Now, divide the output into two halves of 4 bit each. Combine them again, but now the left part should become right and the right part should become left.
After step 3 = 1 1 0 1 1 0 1 0
Step-4:Again perform step 2, but this time while doing XOR operation after expanded permutation use key 2 instead of key 1.
Expand permutation is defined as - 4 1 2 3 2 3 4 1
After second ep = 0 1 0 1 0 1 0 1
After XOR operation with 2nd Key = 0 0 0 1 0 1 1 0
After second S-Boxes = 1 1 1 1

P4 is defined as - 2 4 3 1
After P4 = 1 1 1 1

After XOR operation with left nibble of after first part = 0 0 1 0
After second part = 0 0 1 0 1 0 1 0

l = 1 1 0 1  and r = 1 0 1 0
On the right half, we perform expanded permutation using EP table which converts 4 bits into 8 bits. Expand permutation is defined as –
EP(k1, k2, k3, k4) = (k4, k1, k2, k3, k2, k3, k4, k1)
After second ep = 0 1 0 1 0 1 0 1
We perform XOR operation using second key K2 with the output of expanded permutation.
Key-2 is - 0 1 0 0 0 0 1 1
(0 1 0 0 0 0 1 1) XOR (0 1 0 1 0 1 0 1) =  0 0 0 1 0 1 1 0
After XOR operation with 2nd Key = 0 0 0 1 0 1 1 0
Again we divide the output of XOR into 2 halves of 4 bit each.
l = 0 0 0 1  and r = 0 1 1 0
We take the first and fourth bit as row and the second and third bit as a column for our S boxes.
S0 = [1,0,3,2
      3,2,1,0
      0,2,1,3
      3,1,3,2]

S1 = [0,1,2,3
      2,0,1,3
      3,0,1,0
      2,1,0,3]

For l = 0 0 0 1
row = 01 = 1 , column = 00 = 0
S0 = 3 = 11

For r = 0 1 1 0
row = 00 = 0 , column = 11 = 3
S1 = 3 = 11

After first S-Boxes combining S0 and S1 = 1 1 1 1
S boxes gives a 2-bit output which we combine to get 4 bits and then perform permutation using the P4 table. P4 is defined as – 
P4(k1, k2, k3, k4) = (k2, k4, k3, k1)
After P4 = 1 1 1 1
We XOR the output of the P4 table with the left half of the initial permutation table i.e. IP table.
(1 1 0 1) XOR (1 1 1 1) = 0 0 1 0
After XOR operation with left nibble of after first part = 0 0 1 0
We combine both halves i.e. right half of initial permutation and output of ip.
Combine 1 0 1 0 and 0 0 1 0
After combine = 0 0 1 0 1 0 1 0
After second part = 0 0 1 0 1 0 1 0
Step-5:Perform inverse initial permutation. The output of this table is the cipher text of 8 bit.
Output of step 4 : 0 0 1 0 1 0 1 0
Inverse Initial permutation is defined as –
IP-1(k1, k2, k3, k4, k5, k6, k7, k8) = (k4, k1, k3, k5, k7, k2, k8, k6)
8-bit Cipher Text will be = 0 0 1 1 1 0 0 0 
Java
/*package whatever //do not write package name here */ import java.io.*; public class GFG {    // int key[]= {0,0,1,0,0,1,0,1,1,1};    int key[] = {        1, 0, 1, 0, 0, 0, 0, 0, 1, 0    }; // extra example for checking purpose    int P10[] = { 3, 5, 2, 7, 4, 10, 1, 9, 8, 6 };    int P8[] = { 6, 3, 7, 4, 8, 5, 10, 9 };     int key1[] = new int[8];    int key2[] = new int[8];     int[] IP = { 2, 6, 3, 1, 4, 8, 5, 7 };    int[] EP = { 4, 1, 2, 3, 2, 3, 4, 1 };    int[] P4 = { 2, 4, 3, 1 };    int[] IP_inv = { 4, 1, 3, 5, 7, 2, 8, 6 };     int[][] S0 = { { 1, 0, 3, 2 },                   { 3, 2, 1, 0 },                   { 0, 2, 1, 3 },                   { 3, 1, 3, 2 } };    int[][] S1 = { { 0, 1, 2, 3 },                   { 2, 0, 1, 3 },                   { 3, 0, 1, 0 },                   { 2, 1, 0, 3 } };     //    this function basically generates the key(key1 and    //key2)     using P10 and P8 with (1 and 2)left shifts     void key_generation()    {        int key_[] = new int[10];         for (int i = 0; i < 10; i++) {            key_[i] = key[P10[i] - 1];        }         int Ls[] = new int[5];        int Rs[] = new int[5];         for (int i = 0; i < 5; i++) {            Ls[i] = key_[i];            Rs[i] = key_[i + 5];        }         int[] Ls_1 = shift(Ls, 1);        int[] Rs_1 = shift(Rs, 1);         for (int i = 0; i < 5; i++) {            key_[i] = Ls_1[i];            key_[i + 5] = Rs_1[i];        }         for (int i = 0; i < 8; i++) {            key1[i] = key_[P8[i] - 1];        }         int[] Ls_2 = shift(Ls, 2);        int[] Rs_2 = shift(Rs, 2);         for (int i = 0; i < 5; i++) {            key_[i] = Ls_2[i];            key_[i + 5] = Rs_2[i];        }         for (int i = 0; i < 8; i++) {            key2[i] = key_[P8[i] - 1];        }         System.out.println("Your Key-1 :");         for (int i = 0; i < 8; i++)            System.out.print(key1[i] + " ");         System.out.println();        System.out.println("Your Key-2 :");         for (int i = 0; i < 8; i++)            System.out.print(key2[i] + " ");    }     //    this function is use full for shifting(circular) the    //array n position towards left     int[] shift(int[] ar, int n)    {        while (n > 0) {            int temp = ar[0];            for (int i = 0; i < ar.length - 1; i++) {                ar[i] = ar[i + 1];            }            ar[ar.length - 1] = temp;            n--;        }        return ar;    }     //    this is main encryption function takes plain text as    //input     uses another functions and returns the array of    //cipher text     int[] encryption(int[] plaintext)    {        int[] arr = new int[8];         for (int i = 0; i < 8; i++) {            arr[i] = plaintext[IP[i] - 1];        }        int[] arr1 = function_(arr, key1);         int[] after_swap = swap(arr1, arr1.length / 2);         int[] arr2 = function_(after_swap, key2);         int[] ciphertext = new int[8];         for (int i = 0; i < 8; i++) {            ciphertext[i] = arr2[IP_inv[i] - 1];        }         return ciphertext;    }     // decimal to binary string 0-3     String binary_(int val)    {        if (val == 0)            return "00";        else if (val == 1)            return "01";        else if (val == 2)            return "10";        else            return "11";    }     //    this function is doing core things like expansion    //    then xor with desired key then S0 and S1    //substitution     P4 permutation and again xor     we have used    //this function 2 times(key-1 and key-2) during    //encryption and     2 times(key-2 and key-1) during    //decryption     int[] function_(int[] ar, int[] key_)    {         int[] l = new int[4];        int[] r = new int[4];         for (int i = 0; i < 4; i++) {            l[i] = ar[i];            r[i] = ar[i + 4];        }         int[] ep = new int[8];         for (int i = 0; i < 8; i++) {            ep[i] = r[EP[i] - 1];        }         for (int i = 0; i < 8; i++) {            ar[i] = key_[i] ^ ep[i];        }         int[] l_1 = new int[4];        int[] r_1 = new int[4];         for (int i = 0; i < 4; i++) {            l_1[i] = ar[i];            r_1[i] = ar[i + 4];        }         int row, col, val;         row = Integer.parseInt("" + l_1[0] + l_1[3], 2);        col = Integer.parseInt("" + l_1[1] + l_1[2], 2);        val = S0[row][col];        String str_l = binary_(val);         row = Integer.parseInt("" + r_1[0] + r_1[3], 2);        col = Integer.parseInt("" + r_1[1] + r_1[2], 2);        val = S1[row][col];        String str_r = binary_(val);         int[] r_ = new int[4];        for (int i = 0; i < 2; i++) {            char c1 = str_l.charAt(i);            char c2 = str_r.charAt(i);            r_[i] = Character.getNumericValue(c1);            r_[i + 2] = Character.getNumericValue(c2);        }        int[] r_p4 = new int[4];        for (int i = 0; i < 4; i++) {            r_p4[i] = r_[P4[i] - 1];        }         for (int i = 0; i < 4; i++) {            l[i] = l[i] ^ r_p4[i];        }         int[] output = new int[8];        for (int i = 0; i < 4; i++) {            output[i] = l[i];            output[i + 4] = r[i];        }        return output;    }     //    this function swaps the nibble of size n(4)     int[] swap(int[] array, int n)    {        int[] l = new int[n];        int[] r = new int[n];         for (int i = 0; i < n; i++) {            l[i] = array[i];            r[i] = array[i + n];        }         int[] output = new int[2 * n];        for (int i = 0; i < n; i++) {            output[i] = r[i];            output[i + n] = l[i];        }         return output;    }     //    this is main decryption function    //    here we have used all previously defined function    //    it takes cipher text as input and returns the array    //of     decrypted text     int[] decryption(int[] ar)    {        int[] arr = new int[8];         for (int i = 0; i < 8; i++) {            arr[i] = ar[IP[i] - 1];        }         int[] arr1 = function_(arr, key2);         int[] after_swap = swap(arr1, arr1.length / 2);         int[] arr2 = function_(after_swap, key1);         int[] decrypted = new int[8];         for (int i = 0; i < 8; i++) {            decrypted[i] = arr2[IP_inv[i] - 1];        }         return decrypted;    }     public static void main(String[] args)    {         GFG obj = new GFG();         obj.key_generation(); // call to key generation                              // function         // int []plaintext= {1,0,1,0,0,1,0,1};        int[] plaintext = {            1, 0, 0, 1, 0, 1, 1, 1        }; // extra example for checking purpose         System.out.println();        System.out.println("Your plain Text is :");        for (int i = 0; i < 8; i++) // printing the                                    // plaintext            System.out.print(plaintext[i] + " ");         int[] ciphertext = obj.encryption(plaintext);         System.out.println();        System.out.println(            "Your cipher Text is :"); // printing the cipher                                      // text        for (int i = 0; i < 8; i++)            System.out.print(ciphertext[i] + " ");         int[] decrypted = obj.decryption(ciphertext);         System.out.println();        System.out.println(            "Your decrypted Text is :"); // printing the                                         // decrypted text        for (int i = 0; i < 8; i++)            System.out.print(decrypted[i] + " ");    }} //Omkar Varhadi
Your Key-1 :
1 0 1 0 0 1 0 0 
Your Key-2 :
0 1 0 0 0 0 1 1 
Your plain Text is :
1 0 0 1 0 1 1 1 
Your cipher Text is :
0 0 1 1 1 0 0 0 
Your decrypted Text is :
1 0 0 1 0 1 1 1 
omkara
singghakshay
surinderdawra388
prachisoda1234
cryptography
Computer Networks
cryptography
Computer Networks
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.