Name:Siddhant Thaware

Batch-2
Roll-34
Date:2/8/2023

Assignment-4

S-AES encryption

Code(cpp):

#include <iostream>
#include <string>
#include <cstdlib>
#include <limits>
#include <unordered_map>

using namespace std;

#define PAUSE "pause"

#define CLR "cls"
#define PAUSE "read -p 'Press Enter to continue...' var"
#define CLR "clear"

// Rest of the code remains the same...

// [Rest of the code]

/
******************************************************************
**************************
Simplified - Advanced Encryption Standard CLASS
******************************************************************
**************************/
class SAES
{
//Round Constant
const string RC1 = "10000000"; // Left Byte RC[1] = x^3 = 1000
 const string RC2 = "00110000"; // Left Byte RC[2] = x + 1 =
0011
//S-Box
string SBox[4][4] = { {"1001","0100","1010","1011"},
{"1101","0001","1000","0101"},
{"0110","0010","0000","0011"},
{"1100","1110","1111","0111"} };
string invSBox[4][4] = { {"1010","0101","1001","1011"},
{"0001","0111","1000","1111"},
{"0110","0000","0010","0011"},
{"1100","0100","1101","1110"}};

unordered_map<string,int> stringToInt;
unordered_map<int,string> intToString;

const int TextLength = 16;

const int KeyLength = 16;

string key0; // round 0 key

string key1; // round 1 key
string key2; // round 2 key

string XOR_OP(const string &, const string &);

string key_function_g(const string &, const string&);
string Encryption_Rounds(const string &, const string&, int);
string Decryption_Rounds(const string &, const string&, int);

public:

SAES()
{
key0.resize(KeyLength,'x');
key1.resize(KeyLength,'x');
key2.resize(KeyLength,'x');
stringToInt["00"]=0;
stringToInt["01"]=1;
stringToInt["10"]=2;
stringToInt["11"]=3;
intToString[0]="00";
intToString[1]="01";
intToString[2]="10";
intToString[3]="11";
}

// key generation function

void SAES_KEY_GENERATION(const string&);
string SAES_Encryption(const string&);
string SAES_Decryption(const string&);

string getKey0(){
return key0;
 }

string getKey1(){
return key1;
}

string getKey2(){
return key2;
}

char xor_char(char a, char b, char c='0') {

if (b == c)
return a;
else if(a == '0')
return '1';
else
return '0';
};

};

/
******************************************************************
**************************
S-AES Encryption Function
******************************************************************
**************************/
string SAES::SAES_Encryption(const string& ip)
{

/**** ROUND 0 : ADD ROUND KEY *****/

string cipherOp = XOR_OP(ip, key0);
/**** ROUND 1 *****/
cipherOp = Encryption_Rounds(cipherOp, key1, 1);
/**** ROUND 2 *****/
cipherOp = Encryption_Rounds(cipherOp, key2, 2);

return cipherOp;
}

/
******************************************************************
**************************
S-AES Decryption Function
******************************************************************
**************************/
string SAES::SAES_Decryption(const string& ip)
{

/**** ROUND 0 : ADD ROUND KEY *****/

string plainText = XOR_OP(ip, key2);
/**** ROUND 1 *****/
 plainText = Decryption_Rounds(plainText, key1, 1);
/**** ROUND 2 *****/
plainText = Decryption_Rounds(plainText, key0, 2);

return plainText;
}

/
******************************************************************
**************************
Rounds Used in Encryption
******************************************************************
**************************/
string SAES::Encryption_Rounds(const string &text, const string&
key, int round)
{
int dim = 2; // Matrix Dimensions
vector<vector<string> > StateM(dim, vector<string>(dim)); //
State matrix.

StateM[0][0] = text.substr(0, 4); // Nibble 0 is text 0 to 3

bits
StateM[0][1] = text.substr(8, 4); // Nibble 2 is text 8 to 11
bits
StateM[1][0] = text.substr(4, 4); // Nibble 1 is text 4 to 7
bits
StateM[1][1] = text.substr(12, 4); // Nibble 3 is text 12 to
15 bit

// The rest of the code remains the same...

// Mix Column Using XOR Operation Alternative

if (round != 2)
{
vector<vector<string> > outputM;

for (int i = 0; i < dim; i++)

{
outputM.push_back(vector<string>(dim));

outputM[i][0] = xor_char(StateM[0][i][0], StateM[1][i]

[2]); // b0 = b0^b6
outputM[i][1] = xor_char(StateM[0][i][1], StateM[1][i]
[0], StateM[1][i][3]); // b1 = b1^b4^b7
outputM[i][2] = xor_char(StateM[0][i][2], StateM[1][i]
[0], StateM[1][i][1]); // b2 = b2^b4^b5
outputM[i][3] = xor_char(StateM[0][i][3], StateM[1][i]
[1]); // b3 = b3^b5

outputM[i][4] = xor_char(StateM[0][i][2], StateM[1][i]

[0]); // b4 = b2^b4
 outputM[i][5] = xor_char(StateM[0][i][0], StateM[0][i]
[3], StateM[1][i][1]); // b5 = b0^b3^b5
outputM[i][6] = xor_char(StateM[0][i][0], StateM[0][i]
[1], StateM[1][i][2]); // b6 = b0^b1^b6
outputM[i][7] = xor_char(StateM[0][i][1], StateM[1][i]
[3]); // b7 = b1^b7
}

// Combine the outputM elements back to a single string

string op;
for (int i = 0; i < dim; i++)
{
for (int j = 0; j < dim * 4; j++)
{
op += outputM[i][j];
}
}

return op;
}

/
******************************************************************
**************************
SAES Key Expansion and Generation
******************************************************************
**************************/
void SAES::SAES_KEY_GENERATION(const string& key)
{
// key0
string w0 = key.substr(0,8); // w_0 is key 0 to 7 bits
string w1 = key.substr(8,8); // w_1 is key 8 to 15 bits

key0 = w0+w1;

//key1
string w1g = key_function_g(w1, RC1);

string w2 = XOR_OP(w0, w1g);

string w3 = XOR_OP(w2, w1);

key1 = w2+w3;

//key2
string w3g = key_function_g(w3, RC2);
 string w4 = XOR_OP(w2, w3g);
string w5 = XOR_OP(w4, w3);

key2 = w4+w5;

/
******************************************************************
**************************
Key Transformation Function g used in SAES
******************************************************************
**************************/
string SAES::key_function_g(const string &w, const string& RC)
{
string N0 = w.substr(0,4); // Nibble 0 is w 0 to 3 bits
string N1 = w.substr(4,4); // Nibble 1 is w 4 to 7 bits

int sub_row, sub_col;

sub_row = stringToInt[N1.substr(0,2)]; // Nibble first two
bits are row index for sBox.
sub_col = stringToInt[N1.substr(2,2)]; // Nibble last two bits
are col index for sBox.

string N1_ = SBox[sub_row][sub_col];

sub_row = stringToInt[N0.substr(0,2)]; // Nibble first two

bits are row index for sBox.
sub_col = stringToInt[N0.substr(2,2)]; // Nibble last two bits
are col index for sBox.

string N0_ = SBox[sub_row][sub_col];

string w_ = N1_+N0_; // Swapping of Nibble

string output = XOR_OP(w_, RC);

return output;
}

/
******************************************************************
**************************
XOR Operation between two texts
******************************************************************
**************************/
string SAES::XOR_OP(const string &t1, const string &t2){
string result_xor;
for(int i=0; i<t1.size(); i++){
if(t1[i] == t2[i])
result_xor.push_back('0');
else
 result_xor.push_back('1');
}
return result_xor;
}

/
******************************************************************
**************************
Main Function
******************************************************************
**************************/
int main()
{
char choice;
string ip_plain_txt, op_plain_txt; //plain txt to encrypt
string op_cipher_txt, ip_cipher_txt;
string key;

SAES *obj = new SAES();

do{
char ch;

cout<<endl<<endl<<endl;
//system(PAUSE);
//system(CLR);

cout<<"\n ---------------- SAES Encryption and Decryption

MENU ----------------";

cout<<"\n e. SAES Encryption";

cout<<"\n d. SAES Decryption";

cout<<"\n\n n. Exit - Bye \n\n --Choice : ";

cin>>ch;
cout<<"\n <-------->";

switch(ch){
//encryption
case 'e':
cout << "\n Enter Plain Text String (16-bits) : ";
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
getline(cin, ip_plain_txt);

cout << "\n Enter Key String (16-bits) : ";

getline(cin, key);

// ip_plain_txt="0110111101101011";
//--> op_cipher_txt="0000011100111000";
// key="1010011100111011";

obj->SAES_KEY_GENERATION(key);
 op_cipher_txt = obj-
>SAES_Encryption(ip_plain_txt);

cout<<"\n SAES ENCRYPTION DONE :"

<< "\n :::::=> Plain Text (input) :
"<<ip_plain_txt
<< "\n :::::=> Key0 (input) : " <<obj-
>getKey0()
<< "\t:::=> Key1 : "<<obj->getKey1()
<< "\t:::=> Key2 : " <<obj->getKey2()
<< "\n :::::=> Cipher Text (output) : "
<<op_cipher_txt;

break;
//decryption
case 'd':
cout << "\n Enter Cipher Text String : ";
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
getline(cin, ip_cipher_txt);

cout << "\n Enter Key String (16-bits) : ";

cin >> key;
// ip_cipher_txt="0000011100111000";
// key="1010011100111011";

obj->SAES_KEY_GENERATION(key);
op_plain_txt = obj-
>SAES_Decryption(ip_cipher_txt);

cout<<"\n SAES DECRYPTION DONE :"

<< "\n :::::=> Cipher Text (input) : "
<<ip_cipher_txt
<< "\n :::::=> Key0 (input) : " <<obj-
>getKey0()
<< "\t:::=> Key1 : "<<obj->getKey1()
<< "\t:::=> Key2 : " <<obj->getKey2()
<< "\n :::::=> Plain Text (output) :
"<<op_plain_txt;

break;

case 'n': cout<<"\n Bye \n"; break;

default: cout<< "\n--Invalid Choice. Enter Again \n";
}

choice=ch;
}while(choice != 'n');

// Rest of the code...

delete obj;
cout << "\n Press Enter To Exit. ";
cin.get();
cin.get();
return 0;

OUTPUT: