pastebin

Paste Search Dynamic
Recent pastes
convert Decimal To Binary
  1. // Including dependancies
  2. #include <iostream>
  3. #include <string>
  4. #include <cmath>
  5. using namespace std;
  6. // Array to hold 16 keys
  7. string round_keys[16];
  8. // String to hold the plain text
  9. string pt;
  10. // Function to convert a number in decimal to binary
  11. string convertDecimalToBinary(int decimal)
  12. {
  13.         string binary;
  14.     while(decimal != 0) {
  15.                 binary = (decimal % 2 == 0 ? "0" : "1") + binary;
  16.                 decimal = decimal/2;
  17.         }
  18.         while(binary.length() < 4){
  19.                 binary = "0" + binary;
  20.         }
  21.     return binary;
  22. }
  23. // Function to convert a number in binary to decimal
  24. int convertBinaryToDecimal(string binary)
  25. {
  26.     int decimal = 0;
  27.         int counter = 0;
  28.         int size = binary.length();
  29.         for(int i = size-1; i >= 0; i--)
  30.         {
  31.         if(binary[i] == '1'){
  32.                 decimal += pow(2, counter);
  33.         }
  34.     counter++;
  35.         }
  36.         return decimal;
  37. }
  38. // Function to do a circular left shift by 1
  39. string shift_left_once(string key_chunk){
  40.     string shifted="";  
  41.         for(int i = 1; i < 28; i++){
  42.             shifted += key_chunk[i];
  43.         }
  44.         shifted += key_chunk[0];  
  45.     return shifted;
  46. }
  47. // Function to do a circular left shift by 2
  48. string shift_left_twice(string key_chunk){
  49.     string shifted="";
  50.     for(int i = 0; i < 2; i++){
  51.         for(int j = 1; j < 28; j++){
  52.             shifted += key_chunk[j];
  53.         }
  54.         shifted += key_chunk[0];
  55.         key_chunk= shifted;
  56.         shifted ="";
  57.     }
  58.     return key_chunk;
  59. }
  60. // Function to compute xor between two strings
  61. string Xor(string a, string b){
  62.         string result = "";
  63.         int size = b.size();
  64.         for(int i = 0; i < size; i++){
  65.                 if(a[i] != b[i]){
  66.                         result += "1";
  67.                 }
  68.                 else{
  69.                         result += "0";
  70.                 }
  71.         }
  72.         return result;
  73. }
  74. // Function to generate the 16 keys.
  75. void generate_keys(string key){
  76.         // The PC1 table
  77.         int pc1[56] = {
  78.         57,49,41,33,25,17,9,
  79.         1,58,50,42,34,26,18,
  80.         10,2,59,51,43,35,27,
  81.         19,11,3,60,52,44,36,             
  82.         63,55,47,39,31,23,15,
  83.         7,62,54,46,38,30,22,
  84.         14,6,61,53,45,37,29,
  85.         21,13,5,28,20,12,4
  86.         };
  87.         // The PC2 table
  88.         int pc2[48] = {
  89.         14,17,11,24,1,5,
  90.         3,28,15,6,21,10,
  91.         23,19,12,4,26,8,
  92.         16,7,27,20,13,2,
  93.         41,52,31,37,47,55,
  94.         30,40,51,45,33,48,
  95.         44,49,39,56,34,53,
  96.         46,42,50,36,29,32
  97.         };
  98.         // 1. Compressing the key using the PC1 table
  99.         string perm_key ="";
  100.         for(int i = 0; i < 56; i++){
  101.                 perm_key+= key[pc1[i]-1];
  102.         }
  103.         // 2. Dividing the key into two equal halves
  104.         string left= perm_key.substr(0, 28);
  105.         string right= perm_key.substr(28, 28);
  106.         for(int i=0; i<16; i++){
  107.                 // 3.1. For rounds 1, 2, 9, 16 the key_chunks
  108.                 // are shifted by one.
  109.                 if(i == 0 || i == 1 || i==8 || i==15 ){
  110.                         left= shift_left_once(left);
  111.                         right= shift_left_once(right);
  112.                 }
  113.                 // 3.2. For other rounds, the key_chunks
  114.                 // are shifted by two
  115.                 else{
  116.                         left= shift_left_twice(left);
  117.                         right= shift_left_twice(right);
  118.                 }
  119.                 // Combining the two chunks
  120.                 string combined_key = left + right;
  121.                 string round_key = "";
  122.                 // Finally, using the PC2 table to transpose the key bits
  123.                 for(int i = 0; i < 48; i++){
  124.                         round_key += combined_key[pc2[i]-1];
  125.                 }  
  126.                 round_keys[i] = round_key;
  127.         }
  128.  
  129. }
  130. // Implementing the algorithm
  131. string DES(){
  132.         // The initial permutation table
  133.         int initial_permutation[64] = {
  134.         58,50,42,34,26,18,10,2,
  135.         60,52,44,36,28,20,12,4,
  136.         62,54,46,38,30,22,14,6,
  137.         64,56,48,40,32,24,16,8,
  138.         57,49,41,33,25,17,9,1,
  139.         59,51,43,35,27,19,11,3,
  140.         61,53,45,37,29,21,13,5,
  141.         63,55,47,39,31,23,15,7
  142.         };
  143.         // The expansion table
  144.         int expansion_table[48] = {
  145.         32,1,2,3,4,5,4,5,
  146.         6,7,8,9,8,9,10,11,
  147.         12,13,12,13,14,15,16,17,
  148.         16,17,18,19,20,21,20,21,
  149.         22,23,24,25,24,25,26,27,
  150.         28,29,28,29,30,31,32,1
  151.         };
  152.         // The substitution boxes. The should contain values
  153.         // from 0 to 15 in any order.
  154.         int substition_boxes[8][4][16]=  
  155.         {{
  156.         14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
  157.         0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
  158.         4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
  159.         15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13
  160.     },
  161.     {
  162.         15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
  163.         3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
  164.         0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
  165.         13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9
  166.     },
  167.     {
  168.         10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
  169.         13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
  170.         13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
  171.         1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12
  172.     },
  173.     {
  174.         7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
  175.         13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
  176.         10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
  177.         3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14
  178.     },
  179.     {
  180.         2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
  181.         14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
  182.         4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
  183.         11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3
  184.     },
  185.     {
  186.         12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
  187.         10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
  188.         9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
  189.         4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13
  190.     },
  191.     {
  192.         4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
  193.         13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
  194.         1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
  195.         6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12
  196.     },
  197.     {
  198.         13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
  199.         1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
  200.         7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
  201.         2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11
  202.     }};
  203.         // The permutation table
  204.         int permutation_tab[32] = {
  205.         16,7,20,21,29,12,28,17,
  206.         1,15,23,26,5,18,31,10,
  207.         2,8,24,14,32,27,3,9,
  208.         19,13,30,6,22,11,4,25
  209.         };
  210.         // The inverse permutation table
  211.         int inverse_permutation[64]= {
  212.         40,8,48,16,56,24,64,32,
  213.         39,7,47,15,55,23,63,31,
  214.         38,6,46,14,54,22,62,30,
  215.         37,5,45,13,53,21,61,29,
  216.         36,4,44,12,52,20,60,28,
  217.         35,3,43,11,51,19,59,27,
  218.         34,2,42,10,50,18,58,26,
  219.         33,1,41,9,49,17,57,25
  220.         };
  221.         //1. Applying the initial permutation
  222.         string perm = "";
  223.         for(int i = 0; i < 64; i++){
  224.                 perm += pt[initial_permutation[i]-1];
  225.         }  
  226.         // 2. Dividing the result into two equal halves
  227.         string left = perm.substr(0, 32);
  228.         string right = perm.substr(32, 32);
  229.         // The plain text is encrypted 16 times  
  230.         for(int i=0; i<16; i++) {
  231.         string right_expanded = "";
  232.                 // 3.1. The right half of the plain text is expanded
  233.         for(int i = 0; i < 48; i++) {
  234.                 right_expanded += right[expansion_table[i]-1];
  235.     };  // 3.3. The result is xored with a key
  236.                 string xored = Xor(round_keys[i], right_expanded);  
  237.                 string res = "";
  238.                 // 3.4. The result is divided into 8 equal parts and passed
  239.                 // through 8 substitution boxes. After passing through a
  240.                 // substituion box, each box is reduces from 6 to 4 bits.
  241.                 for(int i=0;i<8; i++){
  242.                         // Finding row and column indices to lookup the
  243.                         // substituition box
  244.                 string row1= xored.substr(i*6,1) + xored.substr(i*6 + 5,1);
  245.                 int row = convertBinaryToDecimal(row1);
  246.                 string col1 = xored.substr(i*6 + 1,1) + xored.substr(i*6 + 2,1) + xored.substr(i*6 + 3,1) + xored.substr(i*6 + 4,1);;
  247.                         int col = convertBinaryToDecimal(col1);
  248.                         int val = substition_boxes[i][row][col];
  249.                         res += convertDecimalToBinary(val);  
  250.                 }
  251.                 // 3.5. Another permutation is applied
  252.                 string perm2 ="";
  253.                 for(int i = 0; i < 32; i++){
  254.                         perm2 += res[permutation_tab[i]-1];
  255.                 }
  256.                 // 3.6. The result is xored with the left half
  257.                 xored = Xor(perm2, left);
  258.                 // 3.7. The left and the right parts of the plain text are swapped
  259.                 left = xored;
  260.                 if(i < 15){
  261.                         string temp = right;
  262.                         right = xored;
  263.                         left = temp;
  264.                 }
  265.         }
  266.         // 4. The halves of the plain text are applied
  267.         string combined_text = left + right;  
  268.         string ciphertext ="";
  269.         // The inverse of the initial permuttaion is applied
  270.         for(int i = 0; i < 64; i++){
  271.                 ciphertext+= combined_text[inverse_permutation[i]-1];
  272.         }
  273.         //And we finally get the cipher text
  274.         return ciphertext;
  275. }
  276. int main(){
  277.         // A 64 bit key
  278.         string key= "1010101010";
  279.         // A block of plain text of 64 bits
  280.         pt= "helloworld";
  281.         // Calling the function to generate 16 keys
  282.         generate_keys(key);
  283.     cout<<"Plain text: "<<pt<<endl;
  284.         // Applying the algo
  285.     string ct= DES();
  286.     cout<<"Ciphertext: "<<ct<<endl;
  287. }
  288.  
  289.  
  290. // 1001111000100110100111110101101011111010010011011011101101110000
  291. // 0100111000111101101000111101100001100101010010011101101011110110
Parsed in 0.047 seconds