#1. Aim: Encrypting and decrypting with a Ceaser Cipher
#include<bits/stdc++.h>
using namespace std;
int k = 3;
int base = 26;

string encrypt(string message){

    string en_str = message;
    for(int i=0; i<message.length(); i++){
        int element = en_str[i];
        int ascii = element - 'A';
        int new_element = (ascii + k)%base + 'A';
        en_str[i] = new_element;
    }

    return en_str;
}


string decrypt(string en_str){

    string de_str = en_str;
    for(int i=0; i<en_str.length(); i++){
        int element = de_str[i];
        int ascii = element - 'A';
        int new_element = (ascii - k);
        if (new_element < 0)
            new_element = 26 + new_element;

        new_element = new_element%base + 'A';
        de_str[i] = new_element;
    }

    return de_str;
}


int main(){

    string message = "CRYPTOGRAPHY";
    string en_str = encrypt(message);
    cout<<endl;
    cout<<en_str<<endl;

    string de_str = decrypt(en_str);
    cout<<de_str<<endl;

    return 0;

}



#2: Aim: decrypting a encrypted word to find its original word and key

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

int base = 26;

string encrypt(string message, int k){

    string en_str = message;
    for(int i=0; i<message.length(); i++){
        int element = en_str[i];
        int ascii = element - 'A';
        int new_element = (ascii + k)%base + 'A';
        en_str[i] = new_element;
    }

    return en_str;
}


string decrypt(string en_str, int k){

    string de_str = en_str;
    for(int i=0; i<en_str.length(); i++){
        int element = de_str[i];
        int ascii = element - 'A';
        int new_element = (ascii - k);
        if (new_element < 0)
            new_element = 26 + new_element;

        new_element = new_element%base + 'A';
        de_str[i] = new_element;
    }

    return de_str;
}


int main(){

    string en_str = "FQOCUDEM";
    //string en_str = encrypt(message);
    //cout<<endl;
    //cout<<en_str<<endl;

    for(int i=0; i<base; i++){
        string de_str = decrypt(en_str, i);
        cout<<i<<". "<<de_str<<endl;
    }
    return 0;

}

#3: Aim: Encryption using Playfair cipher.

#include <bits/stdc++.h>
using namespace std;
map<char, pair<int,int> > reconvert;
map<pair<int,int>, char> convert;
void playfair_matrix(string key){
    map<char, bool> temp;
    int r=0, c=0;
    for(int i=0; i<key.size(); ++i){
        if(isalpha(key[i]) and key[i]!='J' and temp.find(key[i])==temp.end()){
            temp[key[i]] = true;
            reconvert[key[i]] = {r,c};
            convert[{r,c}] = key[i];
            ++c;
            if(c == 5)
                ++r, c=0;
        }
    }
    for(char ch='A'; ch<='Z'; ++ch){
        if(ch!='J' and temp.find(ch) == temp.end()){
            temp[ch] = true;
            reconvert[ch] = {r,c};
            convert[{r,c}] = ch;
            ++c;
            if(c == 5)
                ++r, c=0;
        }
    }
}
string cipher_text(string plain_text){
    int n = 0;
    for(int i=0; i<plain_text.size(); ++i){
        if(isalpha(plain_text[i]))
            plain_text[n++] = plain_text[i];
    }
    plain_text.erase(plain_text.begin()+n, plain_text.end());
    int i = 0;
    while(i<plain_text.size() and i+1<plain_text.size()){
        if(plain_text[i] == plain_text[i+1])
            plain_text.insert(plain_text.begin()+i+1, 'X');
        else
            i += 2;
    }
    if(plain_text.size()%2 == 1)
        plain_text.push_back('X');
    string ret(plain_text.size(), ' ');
    pair<int,int> pos1, pos2;
    for(int i=0,j=1; j<plain_text.size(); i+=2,j+=2){
        pos1 = reconvert[plain_text[i]];
        pos2 = reconvert[plain_text[j]];
        if(pos1.first == pos2.first){
            ret[i] = convert[{pos1.first,(pos1.second+1)%5}];
            ret[j] = convert[{pos2.first,(pos2.second+1)%5}];
        }
        else if(pos1.second == pos2.second){
            ret[i] = convert[{(pos1.first+1)%5,pos1.second}];
            ret[j] = convert[{(pos2.first+1)%5,pos2.second}];
        }
        else{
            ret[i] = convert[{pos1.first,pos2.second}];
            ret[j] = convert[{pos2.first,pos1.second}];
        }
    }
    return ret;
}
string decipher_text(string cipher_text){
    string ret(cipher_text.size(), ' ');
    pair<int,int> pos1, pos2;
    for(int i=0,j=1; j<cipher_text.size(); i+=2,j+=2){
        pos1 = reconvert[cipher_text[i]];
        pos2 = reconvert[cipher_text[j]];
        if(pos1.first == pos2.first){
            ret[i] = convert[{pos1.first,(pos1.second+4)%5}];
            ret[j] = convert[{pos2.first,(pos2.second+4)%5}];
        }
        else if(pos1.second == pos2.second){
            ret[i] = convert[{(pos1.first+4)%5,pos1.second}];
            ret[j] = convert[{(pos2.first+4)%5,pos2.second}];
        }
        else{
            ret[i] = convert[{pos1.first,pos2.second}];
            ret[j] = convert[{pos2.first,pos1.second}];
        }
    }
    int n = 0;
    for(int i=0; i<ret.size(); ++i){
        if(ret[i] != 'X'){
            ret[n++] = ret[i];
        }
    }
    ret.erase(ret.begin()+n, ret.end());
    return ret;
}
int main() {
    string key, plain_text,  cipher_text;
    getline(cin,key);
    getline(cin,plain_text);
    transform(key.begin(), key.end(), key.begin(), towupper);
    transform(plain_text.begin(), plain_text.end(), plain_text.begin(), towupper);
    playfair_matrix(key);
    for(int i=0; i<5; ++i){
        for(int j=0; j<5; ++j){
            cout<<convert[{i,j}]<<" ";
        }
        cout<<endl;
    }
    cout<<(cipher_text = cipher_text(plain_text))<<endl;
    cout<<decipher_text(cipher_text)<<endl;
    return 0;
}


#4: To implement Vignere cipher

#include<bits/stdc++.h>
using namespace std;

string string1 = "lifeisfullofsurprises";
string keyword = "health";

int main(){

int keylen = keyword.length();
int plainlen = string1.length();

int n = ceil(float(plainlen)/keylen);
string r = "";

for(int i=0; i<n; i++){
    r += keyword;
}

//string s = r.substr(0, (r.length() - plainlen%keylen));
string encrypted = "";

for(int i=0; i<string1.length(); i++){
    int j = (r[i] - 'a') + (string1[i] - 'a');
    j = j%26;
    char ch = j + 'a';
    encrypted += ch;
}

cout<<encrypted<<endl;

return 0;
}




#5: To implement Transposition cipher:

#include<bits/stdc++.h>
using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b){
if(a.first<b.first)
return true;
return false;
}

int main(){
int n=6;
int arr[6] = {3, 2, 6, 1, 5, 4};

vector<pair<int,int> > v;

for(int i=0;i<n;i++)
    v.push_back(make_pair(arr[i],i));

sort(v.begin(),v.end(),cmp);

for(int i=0;i<n;i++)
    cout<<v[i].second+1<<" ";

cout<<endl;
}





#6: To implement one-time pad version Vignere cipher:

#include<bits/stdc++.h>
using namespace std;

string string1 = "sendmoremoney";
string string2 = "cashnotneeded";

int arr[13] = {90, 1, 7, 23, 15, 21, 14, 11, 11, 2, 8, 9, 1};

int main(){

string ciphertext = "";
vector<int> v;

for(int i=0; i<string1.length(); i++){
    int j = (string1[i] - 'a' + arr[i])%26;
    char ch = j + 'a';
    ciphertext += ch;
}

cout<<ciphertext<<endl;

for(int i=0; i<string1.length(); i++){
    int j = (string2[i] - 'a' - ciphertext[i] - 'a')%26;
    if(j < 0) j += 26;
    v.push_back(j);
    cout<<j<<" ";
}

cout<<endl;
return 0;

}



#7: To implement Autokey cipher:

#include<bits/stdc++.h>
using namespace std;

int main(){

int key = 7;

string plain = "thehouseisbeingsoldtonight", enc, dec;

enc=(plain[0]+key-'a')%26+'a';

for(int i=1;i<plain.length();i++){
    enc+=(plain[i]+plain[i-1]-'a'-'a')%26+'a';
}

cout<<enc<<endl;

dec=(enc[0]-'a'-key+26)%26+'a';

for(int i=1;i<plain.length();i++){
    dec+=(enc[i]-dec[i-1]+26)%26+'a';
}

cout<<dec;
cout<<endl;
return 0;
}


9. Implement addition, multiplication and inverse operation on GF(2 power 4) with Irreducible polynomial 10011.

Code:

#include<bits/stdc++.h>
#define N 2
using namespace std;
string MOD;
string dp[N][N],idp[N][N],C[N][N];

string stuffZero(string s,int n)
{   while(s.length()<n)
        s='0'+s;
    return s;
}

int binaryToInt(string s)
{   int ans=0;
    reverse(s.begin(),s.end());
    for(int i=0;i<s.length();i++)
        ans+=(1<<i)*(s[i]-'0');
    return ans;
}

string intToBinary(int num)
{   string ans="";
    while(num)
    {   char c=num%2;
        ans+=(c+'0');
        num/=2;
    }
    reverse(ans.begin(),ans.end());
    return ans;
}

int len(int n){
    int m=0;
    while(n){
        n=n/2;
        m++;
    }
    return m;
}

string divide(string m,string MOD) {
    int mod=binaryToInt(MOD),n=binaryToInt(m);
    while(len(n)>=len(mod)){
        n=n^(mod<<(len(n)-len(mod)));
    }
    return intToBinary(n);
}

string add( string s, string p ) {
    int n=binaryToInt(s),m=binaryToInt(p);
    return divide(intToBinary(n^m), MOD);
}
string mul( string s, string p){
    int n = binaryToInt(s),m = binaryToInt(p),ans=0;
    for(int i=0;(1<<i)<=n;i++){
        if(n&(1<<i))
            ans=ans^(m<<i);
    }
    return divide(intToBinary(ans), MOD);
}

void matrixMul(string A[N][N],string B[N][N]){
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++){
        C[i][j]="0";
            for(int k=0;k<N;k++)
                C[i][j]=add(C[i][j],mul(A[i][k],B[k][j]));
}
}



int main()
{
    int c;
    char t='y';
    string s,p;
    cout<<"Enter Irreducible polynomial : ";
    cin>>MOD;

    while(t == 'y'){
    cout<<"\nEnter 1:Addition  2:Multiplication  3:Inverse Operation : ";
    cin>>c;

    switch(c){

        case 1:{
            cout<<"\nADDITION\nEnter the two polynomials : ";
            cin>>s>>p;
            cout<<"Resultant polynomial : "<<stuffZero(add(s,p),2*N)<<endl;
            break;
        }

        case 2:{
            cout<<"\nMULTIPLICATION\nEnter the two polynomials : ";
            cin>>s>>p;
            cout<<"Resultant polynomial : "<<stuffZero(mul(s,p),2*N);
            break;
        }

        case 3:{
            cout<<"\nINVERSE OF A MATRIX\nEnter the matrix :\n";
            for(int i=0;i<N;i++)
                for(int j=0;j<N;j++)
                    cin>>dp[i][j];

            string det=add(mul(dp[0][0],dp[1][1]),mul(dp[0][1],dp[1][0]));
            cout<<"Result of inverse operation : \n";
            idp[0][0]=divide(dp[1][1],det);
            idp[0][1]=divide(dp[1][0],det);
            idp[1][0]=divide(dp[0][1],det);
            idp[1][1]=divide(dp[0][0],det);
            for(int i=0;i<N;i++){
                for(int j=0;j<N;j++)
                    cout<<stuffZero(idp[i][j],2*N)<<" ";
                cout<<endl;
            }
        }
    }

    cout<<"\nWant to perform more operations ? (y/n) : ";
    cin>>t;
    }
    return 0;
}


Output:





10. Implement Mix Column and Inverse Mix Column operations in S – AES with previous Matrix as key.

Code:

#include<bits/stdc++.h>
#define N 2
using namespace std;
string MOD;
string dp[N][N],idp[N][N],C[N][N];
string stuffZero(string s,int n)
{   while(s.length()<n)
        s='0'+s;
    return s;
}
int binaryToInt(string s)
{   int ans=0;
    reverse(s.begin(),s.end());
    for(int i=0;i<s.length();i++)
        ans+=(1<<i)*(s[i]-'0');
    return ans;
}
string intToBinary(int num)
{   string ans="";
    while(num)
    {   char c=num%2;
        ans+=(c+'0');
        num/=2;
    }
    reverse(ans.begin(),ans.end());
    return ans;
}
int len(int n){
    int m=0;
    while(n){
        n=n/2;
        m++;
    }
    return m;
}
string divide(string m,string MOD)
{   int mod=binaryToInt(MOD),n=binaryToInt(m);
    while(len(n)>=len(mod)){
        n=n^(mod<<(len(n)-len(mod)));
    }
    return intToBinary(n);
}
string add( string s, string p )
{   int n=binaryToInt(s),m=binaryToInt(p);
    return divide(intToBinary(n^m), MOD);
}
string mul( string s, string p)
{   int n = binaryToInt(s),m = binaryToInt(p),ans=0;
    for(int i=0;(1<<i)<=n;i++){
        if(n&(1<<i))
            ans=ans^(m<<i);
    }
    return divide(intToBinary(ans), MOD);
}
void matrixMul(string A[N][N],string B[N][N]){
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
        C[i][j]="0";
            for(int k=0;k<N;k++)
                C[i][j]=add(C[i][j],mul(A[i][k],B[k][j]));
        }
    }
}
int main()
{
     int t,c;
    string s,p;
    MOD="10011";
    cout<<"\n** S-AES Encryption **\nEnter the matrix\n";
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
            cin>>dp[i][j];
    string det=add(mul(dp[0][0],dp[1][1]),mul(dp[0][1],dp[1][0]));
    idp[0][0]=divide(dp[1][1],det);
    idp[0][1]=divide(dp[1][0],det);
    idp[1][0]=divide(dp[0][1],det);
    idp[1][1]=divide(dp[0][0],det);
    string A[N][N]={{"0110","1111"},{"0110","1011"}};
    matrixMul(A,dp);
    cout<<"\nMIX COLUMN: \n";
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)
            cout<<stuffZero(C[i][j],2*N)<<" ";
        cout<<endl;
    }
    cout<<endl;
    matrixMul(A,idp);
    cout<<"\nINVERSE MIX COLUMN: \n";
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)
            cout<<stuffZero(C[i][j],2*N)<<" ";
        cout<<endl;
    }
    cout<<endl;
    return 0;
}

OUTPUT:






11. Implement RC4 encryption algorithm


#include<bits/stdc++.h>
using namespace std;
int main()
{
    string plain;
    string key="01010000";
    int keylength=key.length();
    cin>>plain;

    vector<int> S(256);
    vector<int> T(256);


    for(int i=0;i<=255;i++)
    {
        S[i]=i;
        T[i]=key[i%keylength]-'0';
    }

    int j=0;

    for(int i=0;i<=255;i++)
    {
        j=(j+S[i]+T[i])%256;
        int temp=S[i];
        S[i]=S[j];
        S[j]=temp;

    }

    int i=0;
    j=0;
    int k;
    while(true)
    {
        i=(i+1)%256;
        j=(j+S[i])%256;
        int temp=S[i];
        S[i]=S[j];
        S[j]=temp;
        for(int x=0;x<=255;x++)
        cout<<S[x]<<" ";
        cout<<endl;
        k=S[(S[i]+S[j])%256];
        cout<<k<<endl;
        vector<int> bin(8);
        int index=7;
        while(k)
        {
            int x1=k%2;
            bin[index--]=x1;
            k=k/2;
        }
        string cipher="";
        for(int x=0;x<8;x++)
            cipher.push_back(((plain[x]-'0') xor bin[x])+'0');
        cout<<cipher;
        cin>>plain;
    }
}





RC4 alternate code
#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, k;
    cin>>n;
    vector<int> plain_text(n);
    for(int i=0; i<n; ++i)
        cin>>plain_text[i];
    cin>>k;
    vector<int> key(256);
    for(int i=0; i<k; ++i)
        cin>>key[i];
    int s[256];
    for(int i=0; i<256; ++i){
        s[i] = i;
        key[i] = key[i%k];
    }
    int i=0, j=0, t=0;
    for(int i=0; i<256; ++i){
        j = (j + s[i] + key[i])%256;
        swap(s[i],s[j]);
    }
    i = j = 0;
    vector<int> cipher(n), decipher(n);
    for(int p=0; p<n; ++p){
        i = (i + 1)%256;
        j = (j + s[i])%256;
        swap(s[i],s[j]);
        t = s[(s[i]+s[j])%256];
        cipher[p] = plain_text[p] ^ t;
        decipher[p] = cipher[p] ^ t;
    }
    for(int i=0; i<n; ++i)
        cout<<cipher[i]<<" ";
    cout<<endl;
    for(int i=0; i<n; ++i)
        cout<<decipher[i]<<" ";
    cout<<endl;
    return 0;
}




//////RC5
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
const double e = 2.718281828459;
const double f = 1.61803398875;
ll w, r, b, u, t, c, p, q, MOD;

ll odd(double val){
    ll fl = val;
    if(fl & 1)
        return fl;
    return fl+1;
}

ll left_circular_Shift(ll num, ll shift){
    shift %= w;
    return ((1ull<<w)-1) & ((num << shift) | (num >> (w-shift)));
}

ll right_circular_Shift(ll num, ll shift){
    shift %= w;
    return ((1ull<<w)-1) & ((num >> shift) | (num << (w-shift)));
}

int main() {
    cin>>w>>r>>b;
    MOD = 1ull << w;
    t = 2*r+2;
    u = w / 8;
    c = ceil(b*1.0/u);
    p = odd((e-2)*(1ll<<w));
    q = odd((f-1)*(1ll<<w));
    ll plain_text, cipher_text;
    cin>>plain_text;
    vector<ll> key(b), L(c), S(t);
    for(int i=0; i<b; ++i)
        cin>>key[i];
    for(int i=b-1; i>=0; --i)
        L[i/u] = (L[i/u] << 8ull) + key[i];
    S[0] = p;
    for(int i=1; i<t; ++i)
        S[i] = (S[i-1] + q)%MOD;
    ll i=0, j=0;
    ll A=0, B=0;
    for(int z=0; z<3*max(t,c); ++z){
        A = S[i] = left_circular_Shift(((S[i] + A)%MOD + B)%MOD, 3);
        B = L[j] = left_circular_Shift(((L[j] + A)%MOD + B)%MOD, (A + B));
        i = (i + 1)%t;
        j = (j + 1)%c;
    }
    A = plain_text >> w;
    B = ((1ull<<w)-1) & plain_text;
    A = (A + S[0])%MOD;
    B = (B + S[1])%MOD;
    for(int z=1; z<=r; ++z){
        A = (left_circular_Shift((A ^ B), B) + S[2*z])%MOD;
        B = (left_circular_Shift((A ^ B), A) + S[2*z+1])%MOD;
    }
    cipher_text = (A << w) | B;
    cout<<cipher_text<<endl;
    for(int z=r; z>0; --z){
        B = right_circular_Shift(B - S[2*z+1], A) ^ A;
        A = right_circular_Shift(A - S[2*z], B) ^ B;
    }
    B = B - S[1];
    A = A - S[0];
    plain_text = (A << w) | B;
    cout<<plain_text<<endl;
    return 0;
}


12. Implement Fast Exponent Method:

#include<bits/stdc++.h>
using namespace std;

int fast_expo(int base,int power,int mod)
{
    int res=1;
    while(power>0)
    {
        if(power & 1)
            res=(res%mod * base%mod)%mod;
        power=power>>1;
        base=(base%mod * base%mod)%mod;
    }
    return res;
}

int main()
{
    int a,b,c;
    cin>>a>>b>>c;
    cout<<fast_expo(a,b,c)<<endl;
}



13. Implement Euler Totient Function:


#include<bits/stdc++.h>
using namespace std;

int euler_totient(int n)
{
        float ans=n;
        for(int i=2;i*i<=n;i++)
        {
                if(n%i==0)
                        ans*=(1.0-(1.0/(float)i));
                while(n%i==0)
                        n=n/i;
        }
        if(n>1)
                ans*=(1.0-(1.0/(float)n));
        return ans;
}

int main()
{
        int n;
        cin>>n;
        cout<<euler_totient(n)<<endl;
}


#Affine cipher


#include <bits/stdc++.h>
using namespace std;

int extended_euclid(int a, int b, int& x, int& y){
    if(b == 0){
        x = 1;
        y = 0;
        return a;
    }
    int g = extended_euclid(b, a%b, x, y);
    int temp = y;
    y = x - (a/b)*y;
    x = temp;
    return g;
}

int modular_inverse(int a, int mod){
    int x, y;
    int g = extended_euclid(a, mod, x, y);
    if(g != 1)
        return 0;
    return (x + mod)%mod;
}

string affine_cipher(string p, int a, int b, int mod){
    string ret(p.size(), ' ');
    for(int i=0; i<p.size(); ++i){
        if(p[i] == ' ')
            ret[i] = p[i];
        else
            ret[i] = 'a' + (((p[i]-'a')*a + b)%mod + mod)%mod;
    }
    return ret;
}

string affine_decipher(string c, int a, int b, int mod){
    string ret(c.size(), ' ');
    int a_inv = modular_inverse(a,mod);
    for(int i=0; i<c.size(); ++i){
        if(c[i] == ' ')
            ret[i] = c[i];
        else
            ret[i] = 'a' + ((((c[i]-'a') - b)*a_inv)%mod + mod)%mod;
    }
    return ret;
}

int main() {
    string p, c;
    int a, b, mod;
    getline(cin,p);
    cin>>a>>b>>mod;
    cout<<(c = affine_cipher(p,a,b,mod))<<endl;
    cout<<affine_decipher(c,a,b,mod)<<endl;
    return 0;
}


multiplicative cipher



#include <bits/stdc++.h>
using namespace std;

int extended_euclid(int a, int b, int& x, int& y){
    if(b == 0){
        x = 1;
        y = 0;
        return a;
    }
    int g = extended_euclid(b, a%b, x, y);
    int temp = y;
    y = x - (a/b)*y;
    x = temp;
    return g;
}

int modular_inverse(int a, int mod){
    int x, y;
    int g = extended_euclid(a, mod, x, y);
    if(g != 1)
        return 0;
    return (x + mod)%mod;
}

string multiplicative_cipher(string p, int mul){
    string ret(p.size(), ' ');
    for(int i=0; i<p.size(); ++i){
        if(p[i] == ' ')
            ret[i] = p[i];
        else
            ret[i] = 'a' + (((p[i]-'a')*mul)%26 + 26)%26;
    }
    return ret;
}

string multiplicative_decipher(string c, int mul){
    string ret(c.size(), ' ');
    int a_inv = modular_inverse(mul,26);
    for(int i=0; i<c.size(); ++i){
        if(c[i] == ' ')
            ret[i] = c[i];
        else
            ret[i] = 'a' + (((c[i]-'a')*a_inv)%26 + 26)%26;
    }
    return ret;
}

int main() {
    string p, c;
    int mul;
    getline(cin,p);
    cin>>mul;
    cout<<(c = multiplicative_cipher(p,mul))<<endl;
    cout<<multiplicative_decipher(c,mul)<<endl;
    return 0;
}




14. Implement Modular Multiplicative Inverse using Extended Eucledian method.


#include<bits/stdc++.h>
using namespace std;

int gcdextended(int a,int b,int *x,int *y)
{
        if(a==0)
        {
                *x=0;
                *y=1;
                return b;
        }
        int x1,y1;
        int g=gcdextended(b%a,a,&x1,&y1);
        *x=y1-(b/a)*x1;
        *y=x1;
        return g;
}

int mod_inv(int n,int mod)
{
        int x,y;
        int g=gcdextended(n,mod,&x,&y);
        if(g!=1)
                cout<<"Inverse doesn't exist"<<endl;
        else
        {
                int res=(x%mod+mod)%mod;
                return res;
        }
}

int main()
{
        int n;
        int mod;
        cin>>n>>mod;
        cout<<mod_inv(n,mod)<<endl;
}

15. Find the private key for RSA:

#include <bits/stdc++.h>
using namespace std;

int fast_exponentiation(int a, int b, int MOD){
    int ret = 1;
    a = a % MOD;
    while(b != 0){
        if(b & 1)
            ret = (ret * 1ll * a)%MOD;
        a = (a * 1ll * a)%MOD;
        b >>= 1;
    }
    return ret;
}

int extended_euclidean(int a, int b, int& x, int& y){
    if(a == 0){
        x = 0;
        y = 1;
        return b;
    }
    int xx, yy;
    int g = extended_euclidean(b%a, a, xx, yy);
    y = xx;
    x = yy - (b*1ll/a) * xx;
    return g;
}

int modular_inverse(int a, int MOD){
    int x, y;
    if(extended_euclidean(a,MOD,x,y) != 1)
        return 0;
    return (x + MOD)%MOD;
}

int phi(int n){
    int ret = n;
    if(n%2 == 0){
        ret -= ret / 2ll;
        while(n%2 == 0)
            n /= 2;
    }
    int factor = 3;
    int max_factor = sqrt(n);
    while(n!=1 and factor<=max_factor){
        if(n%factor == 0){
            ret -= ret / factor;
            while(n%factor == 0)
                n /= factor;
            max_factor = sqrt(n);
        }
        factor += 2;
    }
    if(n != 1)
        ret -= ret / n;
    return ret;
}

int findPrivateKey(int e, int p, int q){
    int n = p * q;
    int phi_n = (p-1) * (q-1);
    int d = modular_inverse(e,phi_n);
    return d;
}

vector<int> RSAEncrypt(vector<int> plain_text, int e, int p, int q){
    int n = p * q;
    vector<int> cipher_text(plain_text.size());
    for(int i=0; i<plain_text.size(); ++i)
        cipher_text[i] = fast_exponentiation(plain_text[i],e,n);
    return cipher_text;
}

vector<int> RSADecrypt(vector<int> cipher_text, int d, int p, int q){
    int n = p * q;
    vector<int> plain_text(cipher_text.size());
    for(int i=0; i<cipher_text.size(); ++i)
        plain_text[i] = fast_exponentiation(cipher_text[i],d,n);
    return plain_text;
}

int main() {
    int p, q, e, d;
    //cout<<"Enter values of p, q, e: ";
    cin>>p>>q>>e;
    d = findPrivateKey(e,p,q);
    cout<<"Private Key = "<<d<<endl;
    string str;
    cin>>str;
    vector<int> plain_text;
    for(int i=0; i<str.size(); ++i)
        plain_text.push_back((int)str[i]);
    vector<int> cipher_text = RSAEncrypt(plain_text,e,p,q);
    for(int i=0; i<cipher_text.size(); ++i)
        cout<<cipher_text[i]<<" ";
    cout<<endl;
    plain_text = RSADecrypt(cipher_text,d,p,q);
    for(int i=0; i<plain_text.size(); ++i)
        cout<<plain_text[i]<<" ";
    cout<<endl;
    return 0;
}


elliptic curve


#include <bits/stdc++.h>
using namespace std;

int power(int a, int b, int MOD){
    int ret = 1;
    a %= MOD;
    while(b != 0){
        if(b & 1)
            ret = (ret * 1ll * a)%MOD;
        a = (a * 1ll * a)%MOD;
        b >>= 1;
    }
    return ret;
}

int extended_euclidean(int a, int b, int& x, int& y){
    if(a == 0){
        x = 0;
        y = 1;
        return b;
    }
    int x1, y1;
    int g = extended_euclidean(b%a,a,x1,y1);
    x = y1 - (b/a) * x1;
    y = x1;
    return g;
}

int modular_inverse(int a, int n){
    int x, y;
    if(extended_euclidean(a,n,x,y) != 1)
        return 0;
    return (x + n)%n;
}

bool isPrimitive(int x, int p){
    set<int> hash;
    for(int e=1; e<p; ++e)
        hash.insert(power(x,e,p));
    return hash.size() == p-1;
}

void generateKey(int p, int& e1, int& e2, int& d){
    d = 2 + (rand() % (p-3));
    vector<int> primitive;
    for(int i=1; i<p; ++i){
        if(isPrimitive(i,p))
            primitive.push_back(i);
    }
    int idx = rand() % primitive.size();
    e1 = primitive[idx];
    e2 = power(e1,d,p);
}

vector< pair<int,int> > elgamalEncrypt(string plain_text, int k, int e1, int e2, int p){
    vector< pair<int,int> > cipher_text(plain_text.size());
    for(int i=0; i<plain_text.size(); ++i){
        int c1 = power(e1,k,p);
        int c2 = power(e2,k,p);
        int P = (int)plain_text[i];
        cout<<P<<" ";
        c2 = (c2 * 1ll * P)%p;
        cipher_text[i] = {c1,c2};
    }
    cout<<endl;
    return cipher_text;
}

vector<int> elgamalDecrypt(vector< pair<int,int> >& cipher_text, int d, int p){
    vector<int> plain_text(cipher_text.size());
    for(int i=0; i<cipher_text.size(); ++i){
        int c1 = cipher_text[i].first;
        int c2 = cipher_text[i].second;
        c1 = power(c1,d,p);
        c1 = modular_inverse(c1,p);
        plain_text[i] = (c1 * 1ll * c2)%p;
    }
    return plain_text;
}

int main() {
    int p, e1, e2, d, k;
    string plain_text;
    getline(cin,plain_text);
    cin>>p;
    generateKey(p,e1,e2,d);
    k = 1 + rand() % (p-1);
    cout<<"e1 = "<<e1<<" e2 = "<<e2<<" d = "<<d<<" k = "<<k<<endl;
    vector< pair<int,int> > cipher_text = elgamalEncrypt(plain_text,k,e1,e2,p);
    cout<<"Encrypted text: ";
    for(int i=0; i<cipher_text.size(); ++i)
        cout<<cipher_text[i].first<<" "<<cipher_text[i].second;
    cout<<endl;
    vector<int> ptext = elgamalDecrypt(cipher_text,d,p);
    cout<<"Decrypted text: ";
    for(int i=0; i<ptext.size(); ++i)
        cout<<ptext[i]<<" ";
    cout<<endl;
    return 0;
}







Elgamal



#include <bits/stdc++.h>
using namespace std;

int power(int a, int b, int MOD){
    int ret = 1;
    a %= MOD;
    while(b != 0){
        if(b & 1)
            ret = (ret * 1ll * a)%MOD;
        a = (a * 1ll * a)%MOD;
        b >>= 1;
    }
    return ret;
}

int extended_euclidean(int a, int b, int& x, int& y){
    if(a == 0){
        x = 0;
        y = 1;
        return b;
    }
    int x1, y1;
    int g = extended_euclidean(b%a,a,x1,y1);
    x = y1 - (b/a) * x1;
    y = x1;
    return g;
}

int modular_inverse(int a, int n){
    int x, y;
    if(extended_euclidean(a,n,x,y) != 1)
        return 0;
    return (x + n)%n;
}

bool isPrimitive(int x, int p){
    set<int> hash;
    for(int e=1; e<p; ++e)
        hash.insert(power(x,e,p));
    return hash.size() == p-1;
}

void generateKey(int p, int& e1, int& e2, int& d){
    d = 2 + (rand() % (p-3));
    vector<int> primitive;
    for(int i=1; i<p; ++i){
        if(isPrimitive(i,p))
            primitive.push_back(i);
    }
    int idx = rand() % primitive.size();
    e1 = primitive[idx];
    e2 = power(e1,d,p);
}

vector< pair<int,int> > elgamalEncrypt(string plain_text, int k, int e1, int e2, int p){
    vector< pair<int,int> > cipher_text(plain_text.size());
    for(int i=0; i<plain_text.size(); ++i){
        int c1 = power(e1,k,p);
        int c2 = power(e2,k,p);
        int P = (int)plain_text[i];
        cout<<P<<" ";
        c2 = (c2 * 1ll * P)%p;
        cipher_text[i] = {c1,c2};
    }
    cout<<endl;
    return cipher_text;
}

vector<int> elgamalDecrypt(vector< pair<int,int> >& cipher_text, int d, int p){
    vector<int> plain_text(cipher_text.size());
    for(int i=0; i<cipher_text.size(); ++i){
        int c1 = cipher_text[i].first;
        int c2 = cipher_text[i].second;
        c1 = power(c1,d,p);
        c1 = modular_inverse(c1,p);
        plain_text[i] = (c1 * 1ll * c2)%p;
    }
    return plain_text;
}

int main() {
    int p, e1, e2, d, k;
    string plain_text;
    getline(cin,plain_text);
    cin>>p;
    generateKey(p,e1,e2,d);
    k = 1 + rand() % (p-1);
    cout<<"e1 = "<<e1<<" e2 = "<<e2<<" d = "<<d<<" k = "<<k<<endl;
    vector< pair<int,int> > cipher_text = elgamalEncrypt(plain_text,k,e1,e2,p);
    cout<<"Encrypted text: ";
    for(int i=0; i<cipher_text.size(); ++i)
        cout<<cipher_text[i].second<<"  ";
    cout<<endl;
    vector<int> ptext = elgamalDecrypt(cipher_text,d,p);
    cout<<"Decrypted text: ";
    for(int i=0; i<ptext.size(); ++i)
        cout<<ptext[i]<<" ";
    cout<<endl;
    return 0;
}





. Implement Elgamal Digital Signature

#include<bits/stdc++.h>
using namespace std;
int modInverse(int a, int m){
    a = a%m;
    for (int x=1; x<m; x++)
        if ((a*x) % m == 1)
            return x;
}
int exp(int b,int e,int m){
    int r=1;
    while(e>0){
        if(e&1)
            r=(r*b)%m;
        e/=2;
        b=(b*b)%m;
    }
    return r;
}
int main(){
    int m,p,e1,d,r;
    cout<<"** Elgamal Digital Signature **\nEnter m, p, e1, d ,r: ";
    cin>>m>>p>>e1>>d>>r;
    int e2=exp(e1,d,p);
    int s1=exp(e1,r,p);
    int rr=modInverse(r,p-1);
    int s2=((m-d*s1)*rr)%(p-1);
    while(s2<0)
        s2+=p-1;
    s2=s2%(p-1);
    int v2=(exp(e2,s1,p)*exp(s1,s2,p))%p;
    int v1=exp(e1,m,p);
    cout<<"\nv1 = "<<v1<<endl<<"v2 = "<<v2<<endl;
    if(v1==v2)
        cout<<"Accept"<<endl;
    else
        cout<<"Reject"<<endl;
    return 0;
}
OUTPUT:


 . RSA Digital Signature

#include <bits/stdc++.h>
using namespace std;
int ext_eucl(int p, int m, int *x, int *y) {
if(p == 0) {
*x = 0; *y = 1;
return m;
}
int x1, y1;
int gcd = ext_eucl(m % p, p, &x1, &y1);
*x = y1 ­ (m / p) * x1;
*y = x1;
return gcd;
}

int gcd(int a, int b) {
if(a == 0) return b;
return gcd(b % a, a);
}

long long int mod_exp(long long int a, unsigned int p, int n) {
long long int res = 1;

while(p > 0) {
if(p & 1) res = (res * a) % n;
p = p >> 1;
a = (a * a) % n;
}
return res;
}

int coprime(int val) {
for(int i = val / 2; i < val; i += 1)
if(gcd(i, val) == 1) return i;
}

int main() {
int p=55243, q=7669, n;
long long int m=10;
n = p * q;
int totient = (p ­ 1) * (q ­ 1); int e = coprime(totient);
cout << "E " << e << endl;
int d = 0, y = 0;
ext_eucl(e, totient, &d, &y);
long long int encr = mod_exp(m, e, n);
long long int decr = mod_exp(encr, d, n);
cout << "Cipher: " << decr << endl;
cout << "Decrypt: " << encr << endl;
}


Output:
E 211797829
Cipher: 140699680
Decrypt: 10

. ELGAMAL SIMULATED BY ELLIPTIC CURVE CRYPTOGRAPHY

#include<bits/stdc++.h>
using namespace std;
struct coord
{   int x;  int y;   };
int inverse(int a, int p)
{
    for(int i = 1; i < p; i += 1)
        if((a * i) % p == 1)
            return i;
}
coord generate(int a, int b, int p)
{
    vector<int> y_2;
    vector<int> x;
    for(int i = 0; i < p; i += 1)
    {
        y_2.push_back((i * i * i + a * i + b) % p);
        x.push_back(i);
    }
    for(int i = 0; i < p; i += 1)
    {
        for(int j = 0; j < x.size(); j += 1)
        {
            if(y_2[j] == ((i * i) % p))
            {
                coord res;
                res.x = x[j];
                res.y = i;
                return res;
}   }   }   }
int find_lambda(struct coord a, struct coord b, int p)
{
    int lambda;
    if((a.x == b.x) && (a.y == b.y))
    {
        int nr = (p + 3 * a.x * a.x + 1);int dr = (p + 2 * a.y);
        lambda = (p + nr * inverse(dr, p)) % p;
    }
    else
    {
        int nr = (b.y - a.y);       int dr = (b.x - a.x);
        lambda = (p + nr * inverse(dr, p)) % p;
    }
    return lambda;
}
struct coord addn(struct coord a, struct coord b, int p)
{
    struct coord res;   int lambda = find_lambda(a, b, p);
    res.x = (p + lambda * lambda - a.x - b.x) % p;
    res.y = (p + lambda * (a.x - res.x) - a.y) % p;
    return res;
}

struct coord mult(int d, struct coord e1, int p){
    coord e2;   int v = d;
    struct coord temp;
    temp.x = e1.x;  temp.y = e1.y;
    for(int i = 0; i < v; i += 1){
        if(temp.x < 0) temp.x += p;
        if(temp.y < 0) temp.y += p;
        if(temp.x == e1.x && (temp.y != e1.y)){
            temp = e1;
            i += 2;
        }
        else    temp = addn(temp, e1, p);
    }
    e2.x = ((temp.x >= 0) ? (temp.x) : (p + temp.x));
    e2.y = ((temp.y >= 0) ? (temp.y) : (p + temp.y));
    return e2;
}

int main(){
    int p, a, b, d; cout<<"** ELLPTIC CURVE SIMULATING ELGAMAL **\nEnter p, a, b, d: ";
    cin >> p >> a >> b >> d;
    struct coord plain;
    struct coord e1 = generate(a, b, p);    struct coord e2 = mult(d, e1, p);
    cout << "E1 " << e1.x << " " << e1.y << endl;
    cout << "E2 " << e2.x << " " << e2.y << endl;
    int r = 27;
    struct coord c1 = mult(r, e1, p);
    cout << "C1 " << c1.x << " " << c1.y << endl;
    cout<<"\n Enter the number of test case: "; int t;  cin>>t;
    for(int i=0;i<t;i++){
    cout<<"\nENter Coordinates: ";
    cin >> plain.x >> plain.y;
    struct coord c2 = addn(plain, mult(r, e2, p), p);
    cout << "C2 " << c2.x << " " << c2.y << endl;
    struct coord decr = addn(c2, mult(-1, mult(d, c1, p), p), p);
    cout << "Decrypted " << ((decr.x >= 0) ? (decr.x) : (p + decr.x)) << " " << ((decr.y >= 0) ? (decr.y) : (p + decr.y)) << endl;
    }
    return 0;
}
OUTPUT:


 . Generate keys and Implement 4 basic operations of MD5

#include<bits/stdc++.h> using namespace std;
map<char,string> m;
map<string,char> m1;

string no(string x)
{
for(int i=0;i<x.length();i++)
{ if(x[i]=='1') x[i]='0'; else
x[i]='1';
}
return x;
}

string xo(string a,string b)
{ string r="";
for(int i=0;i<a.length();i++)
{if(a[i]==b[i]) r='0'+r; else r='1'+r;
} return r;
}

string oR(string a,string b)
{ string r=""; for(int i=0;i<a.length();i++) {if((a[i]=='1')||(b[i]=='1')) r='1'+r; else r='0'+r;
} return r;
}

string an(string a,string b)
{ string r=""; for(int i=0;i<a.length();i++) {if(a[i]==b[i]) r=a[i]+r; else r='0'+r;
}
return r;
}

string hex(string a)
{
string hex="",temp;
for(int i=0;i<a.length();)
{
temp=""; for(int k=0;k<4;k++,i++)
{
temp+=a[i];
    }
hex+=m1[temp];
}
return hex;
}











int main() {

m['0']="0000";m['1']="0001";m['2']="0010";m['3']="0011";m['4']="0100"
;m['5']="0101";m['6']="0110";m['7']="0111";m['8']="1000";m['9']="1001";
m['A']="1010";m['B']="1011";m['C']="1100";m['D']="1101";
m['E']="1110";m['F']="1111";
m1["0000"]='0';m1["0001"]='1';m1["0010"]='2';
m1["0011"]='3';m1["0100"]='4';m1["0101"]='5';m1["
0110"]='6';m1["0111"]='7';m1["1000"]='8';m1["1001"]='9';
m1["1010"]='A';m1["1011"]='B';m1["1100"]='C';
m1["1101"]='D';m1["1110"]='E';m1["1111"]='F';


long long k[65]; cout<<"Keys:\n";
for(int i=1;i<=64;i++)
{
k[i]=abs(sin(i+1))*pow(2,32); cout<<k[i]<<" ";
}

string a="",b="",c="",d="";
string s1="67452301",s2="EFCDAB89",s3="98BADCFE",s4="10325476";
for(int i=0;i<s1.length();i++)
{
a=m[s1[i]]+a; b=m[s2[i]]+b; c=m[s3[i]]+c;
d=m[s4[i]]+d;
}

//Operation A
string ans=oR(an(b,c),an(no(b),d));
    cout<<endl<<"Op A: "<<hex(ans)<<endl;
//B
ans=oR(an(d,b),an(no(d),c));
cout<<"Op B: "<<hex(ans)<<endl;
//C
ans=xo(b,xo(c,d));
cout<<"Op C: "<<hex(ans)<<endl;
//D
ans=xo(c,oR(b,no(d)));
cout<<"Op D: "<<hex(ans)<<endl;
}

Output:
Keys:
3905402710 606105819 3250441966 4118548399 1200080426 2821735955 4249261313
1770035416 2336552879 4294925233 2304563134 1804603682 4254626195 2792965006
1236535329 4129170786 3225465664 643717713 3921069994 3593408605 38016083
3634488961 3889429448 568446438 3275163606 4107603335 1163531501 2850285829
4243563512 1735328473 2368359562 4294588738 2272392833 1839030562 4259657740
2763975236 1272893353 4139469664 3200236656 681279174 3936430074 3572445317
76029189 3654602809 3873151461 530742520 3299628645 4096336452 1126891415
2878612391 4237533241 1700485571 2399980690 4293915773 2240044497 1873313359 4264355552 2734768916 1309151649 4149444226 3174756917 718787259 3951481745
3551202137
Op A: EFCDAB89
Op B: 88888888
Op C: F7B3D591
Op D: 096F6F09






 . MD5 hash function

#include<bits/stdc++.h> using namespace std;
map<string,char> m;

int main()
{
m['0']="0000";m['1']="0001";m['2']="0010";m['3']="0011";m['4']="0100"
;m['5']="0101";m['6']="0110";m['7']="0111";m['8']="1000";m['9']="1001";
m['A']="1010";m['B']="1011";m['C']="1100";m['D']="1101";
m['E']="1110";m['F']="1111";
m1["0000"]='0';m1["0001"]='1';m1["0010"]='2';
m1["0011"]='3';m1["0100"]='4';m1["0101"]='5';m1["
0110"]='6';m1["0111"]='7';m1["1000"]='8';m1["1001"]='9';
m1["1010"]='A';m1["1011"]='B';m1["1100"]='C';
m1["1101"]='D';m1["1110"]='E';m1["1111"]='F';
string input="hello";
string pad="",temp="";
int i;
for(i=0;i<input.size();i++) {
int x=(int)(input[i]); temp=""; for(int j=0;j<8;j++)
{
temp=(char)(x%2+'0')+temp;
x=x/2;
}
pad=pad+temp;
}

i=pad.length();

if(i<=447) {
pad+='1';
i++;
}

while(i<448) {
pad+='0';
i++;
}

int tmp=input.length()*8;
temp="";

for(i=0;i<64;i++) {
 temp=(char)(tmp%2+'0')+temp;
 tmp=tmp/2;
}
pad=pad+temp; string hex=""; temp="";

for(i=0;i<pad.length();) {
temp=""; for(int k=0;k<4;k++,i++)
{
temp+=pad[i];
    }
hex+=m[temp];
}
cout<<hex<<endl;
}
Output:
68656C6C6F80000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000028
   . Append bits to the given input according to SHA-1 and print results in Hexadecimal Representation.
Input: hello.

#include<bits/stdc++.h>
using namespace std;

int main(){
    string msg = "hello";
    int data[512] = {0};
    int i;
    for(int j=0; j<msg.length(); j++){
        int bin = msg[j];
        i = (j+1)*8;
        while(i>j*8){
            data[i-1] = (bin)%2;
            bin = bin>>1;
            //cout<<".";
            i--;
        }
    }

    data[8*msg.length()] = 1;
    int len = 511;
    int num = 8*msg.length();
    while(num>0){
        data[len] = num%2;
        num = num>>1;
        len--;
    }

    /*for(int j=0; j<512; j++){
        cout<<data[j];
    }
    cout<<endl;*/

    for(int j=0; j<512; j+=4){
        int n = 0;
        n = pow(2, 3)*data[j] + pow(2, 2)*data[j+1] + pow(2, 1)*data[j+2] + pow(2, 0)*data[j+3];
        if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
    }
    cout<<endl;

    return 0;
}

Output:
68656C6C6F80000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000028
  . Implement 4 major operations/processes with give below input and print result in hexadecimal representation.

#include<bits/stdc++.h>
using namespace std;

int main(){

    /*long long int q = pow(2, 32);
    for(int i=1; i<=64; i++){
        long long int k_i = abs(sin(i))*(float)q;
        cout<<k_i<<endl;
    }
    cout<<endl;*/

    int a[8] = {0, 1, 2, 3, 4, 5, 6, 7};
    int b[8] = {8, 9, 10, 11, 12, 13, 14, 15};
    int c[8] = {15, 14, 13, 12, 11, 10, 9, 8};
    int d[8] = {7, 6, 5, 4, 3, 2, 1, 0};
    int e[8] = {12, 3, 13, 2, 14, 1, 15, 0};

    int A[8], B[8], C[8], D[8];

    for(int i=0; i<8; i++){
        int n = A[i] = (b[i]&c[i]) | (~b[i]&d[i]&15);
        if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
    }
    cout<<endl;

    for(int i=0; i<8; i++){
        int n = B[i] = (b[i]^c[i]^d[i]);
        if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
    }
    cout<<endl;









    for(int i=0; i<8; i++){
        int n = C[i] = ((b[i]&c[i]) | (b[i]&d[i]) | (c[i]&d[i]));
        if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
    }
    cout<<endl;

    for(int i=0; i<8; i++){
        int n = D[i] = (b[i]^c[i]^d[i]);
        if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
    }
    cout<<endl;

    return 0;
}


OUTPUT:

FEDCBA98
01234567
FEDCBA98
01234567

  . Implement 2 round of SHA-1 with given 2 inputs respectively.

#include<bits/stdc++.h>
using namespace std;

void print_hex(int n){
    if(n==15) cout<<'F';
        else if(n==14) cout<<'E';
        else if(n==13) cout<<'D';
        else if(n==12) cout<<'C';
        else if(n==11) cout<<'B';
        else if(n==10) cout<<'A';
        else cout<<n;
}

long long int convert_num(int* a){

    long long int n = 0;
    for(int i=0; i<8; i++){
        n += pow(a[i], 7-i);
    }

    return n;
}

string convert_hex(long long int n){

    string hexdec_num="";
    char hex[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

    while(dec_num>0)
        {
            r = dec_num % 16;
            hexdec_num = hex[r] + hexdec_num;
            dec_num = dec_num/16;
        }

     return hexdec_num;

}

int convert_hex_n(char c){
    int n;
    if(c =='F') n = 15;
    else if(c =='E') n = 14;
    else if(c =='D') n = 13;
    else if(c =='C') n = 12;
    else if(c =='B') n = 11;
    else if(c =='A') n = 10;
    else return c-48;
}





int main(){

    string msg = "hello";
    int data[512] = {0};
    int i;
    for(int j=0; j<msg.length(); j++){
        int bin = msg[j];
        i = (j+1)*8;
        while(i>j*8){
            data[i-1] = (bin)%2;
            bin = bin>>1;
            //cout<<".";
            i--;
        }
    }

    data[8*msg.length()] = 1;
    int len = 511;
    int num = 8*msg.length();
    while(num>0){
        data[len] = num%2;
        num = num>>1;
        len--;
    }

    int w[128];
    for(int j=0; j<512; j+=4){
        int n = 0;
        n = pow(2, 3)*data[j] + pow(2, 2)*data[j+1] + pow(2, 1)*data[j+2] + pow(2, 0)*data[j+3];
        w[j/4] = n;
    }

    long long int q = pow(2, 32);

    int a[8] = {0, 1, 2, 3, 4, 5, 6, 7};
    int b[8] = {8, 9, 10, 11, 12, 13, 14, 15};
    int c[8] = {15, 14, 13, 12, 11, 10, 9, 8};
    int d[8] = {7, 6, 5, 4, 3, 2, 1, 0};
    int e[8] = {12, 3, 13, 2, 14, 1, 15, 0};

    int kt[8] = {15, 14, 13, 12, 11, 10, 9, 8};

    int A[8], B[8], C[8], D[8], E[8], F[8];

    for(int i=0; i<8; i++){
        int n = F[i] = (b[i]&c[i]) | (~b[i]&d[i]&15);
        A[i] = a[i]; B[i] = b[i]; C[i] = c[i]; D[i] = d[i]; E[i] = e[i];

    }
    cout<<endl;

    int n;
    int temp[8], data_temp[8];;
    long long int m = (convert_num(F) + convert_num(E))%q;
    string hex_m = convert_hex(m);


    for(int i=0; i<8; i++){
        temp[i] = convert_hex_n(hex_m[i]);
        data_temp[i] = w[i];
    }

    m = (convert_num(temp) + convert_num(data_temp))%q;
    string hex_m = convert_hex(m);
    for(int i=0; i<8; i++){
        temp[i] = convert_hex_n(hex_m[i]);
        data_temp[i] = w[i];
    }

    m = (convert_num(temp) + convert_num(kt))%q;
    string hex_m = convert_hex(m);
    for(int i=0; i<8; i++){
        temp[i] = convert_hex_n(hex_m[i]);
        data_temp[i] = w[i];
    }

    for(int i=0; i<8; i++){
        int n = C[i] = (b[i]^c[i]^d[i]);

    }
    cout<<endl;

    for(int i=0; i<8; i++){
        int n = D[i] = (c[i]^(b[i]|~d[i]&15));

    }
    cout<<endl;

    return 0;
}

OUTPUT:
Round1: 9cf5caf6c36f5cccde8c73fad8894c958f4983da
Round2: 1eec5eecf3ddf2d401205eb87055d6595a9bceaf


  . PRIMITIVE ROOTS OF A MULTIPLICATIVE GROUP

#include<bits/stdc++.h>
#include<time.h>
using namespace std;
int gcd(int a,int b){
    if(!b)
        return a;
    return gcd(b,a%b);
}
int fastexp(int x,int y, int mod){
    int res=1;
    while(y){
        if(y&1)
            res=(res*x)%mod;
        x=(x*x)%mod;
        y=y>>1;
    }
    return res;
}
vector<int> find_generator(int prime){
    int i;
    vector<int> elements, primitives;
    for(i=0;i<prime;i++){
        if(gcd(prime,i)==1)
            elements.push_back(i);
    }
    int order=elements.size();
    for(i=0;i<order;i++){
        int j;
        vector<bool> p(prime,0);
        for(j=0;j<prime;j++){
            int t=fastexp(elements[i],j,prime);
            p[t]=1;
        }
        for(j=1;j<prime;j++)
            if(p[j]==0)
                break;
        if(j==prime)
            primitives.push_back(elements[i]);
    }
    return  primitives;
}
int main(){
    int prime;
    cout<<"Enter the value of p"<<endl;
    cin>>prime;
    vector<int> generators=find_generator(prime);
    cout<<"The generators of prime "<<prime<<" are: "<<endl;
    for(auto generator:generators)
        cout<<generator<<" ";
    return 0;
}
OUTPUT:









  . Implement Elgamal Digital Signature

#include<bits/stdc++.h>
using namespace std;
int modInverse(int a, int m){
    a = a%m;
    for (int x=1; x<m; x++)
        if ((a*x) % m == 1)
            return x;
}
int exp(int b,int e,int m){
    int r=1;
    while(e>0){
        if(e&1)
            r=(r*b)%m;
        e/=2;
        b=(b*b)%m;
    }
    return r;
}
int main(){
    int m,p,e1,d,r;
    cout<<"** Elgamal Digital Signature **\nEnter m, p, e1, d ,r: ";
    cin>>m>>p>>e1>>d>>r;
    int e2=exp(e1,d,p);
    int s1=exp(e1,r,p);
    int rr=modInverse(r,p-1);
    int s2=((m-d*s1)*rr)%(p-1);
    while(s2<0)
        s2+=p-1;
    s2=s2%(p-1);
    int v2=(exp(e2,s1,p)*exp(s1,s2,p))%p;
    int v1=exp(e1,m,p);
    cout<<"\nv1 = "<<v1<<endl<<"v2 = "<<v2<<endl;
    if(v1==v2)
        cout<<"Accept"<<endl;
    else
        cout<<"Reject"<<endl;
    return 0;
}
OUTPUT:



  . ELGAMAL SIMULATED BY ELLIPTIC CURVE CRYPTOGRAPHY

#include<bits/stdc++.h>
using namespace std;
struct coord
{   int x;  int y;   };
int inverse(int a, int p)
{
    for(int i = 1; i < p; i += 1)
        if((a * i) % p == 1)
            return i;
}
coord generate(int a, int b, int p)
{
    vector<int> y_2;
    vector<int> x;
    for(int i = 0; i < p; i += 1)
    {
        y_2.push_back((i * i * i + a * i + b) % p);
        x.push_back(i);
    }
    for(int i = 0; i < p; i += 1)
    {
        for(int j = 0; j < x.size(); j += 1)
        {
            if(y_2[j] == ((i * i) % p))
            {
                coord res;
                res.x = x[j];
                res.y = i;
                return res;
}   }   }   }
int find_lambda(struct coord a, struct coord b, int p)
{
    int lambda;
    if((a.x == b.x) && (a.y == b.y))
    {
        int nr = (p + 3 * a.x * a.x + 1);int dr = (p + 2 * a.y);
        lambda = (p + nr * inverse(dr, p)) % p;
    }
    else
    {
        int nr = (b.y - a.y);       int dr = (b.x - a.x);
        lambda = (p + nr * inverse(dr, p)) % p;
    }
    return lambda;
}
struct coord addn(struct coord a, struct coord b, int p)
{
    struct coord res;   int lambda = find_lambda(a, b, p);
    res.x = (p + lambda * lambda - a.x - b.x) % p;
    res.y = (p + lambda * (a.x - res.x) - a.y) % p;
    return res;
}

struct coord mult(int d, struct coord e1, int p)
{
    coord e2;   int v = d;
    struct coord temp;
    temp.x = e1.x;  temp.y = e1.y;
    for(int i = 0; i < v; i += 1)
    {
        if(temp.x < 0)
            temp.x += p;
        if(temp.y < 0)
            temp.y += p;
        if(temp.x == e1.x && (temp.y != e1.y))
        {
            temp = e1;
            i += 2;
        }
        else    temp = addn(temp, e1, p);
    }
    e2.x = ((temp.x >= 0) ? (temp.x) : (p + temp.x));
    e2.y = ((temp.y >= 0) ? (temp.y) : (p + temp.y));
    return e2;
}

int main()
{
    int p, a, b, d; cout<<"** ELLPTIC CURVE SIMULATING ELGAMAL **\nEnter p, a, b, d: ";
    cin >> p >> a >> b >> d;
    struct coord plain;
    struct coord e1 = generate(a, b, p);    struct coord e2 = mult(d, e1, p);
    cout << "E1 " << e1.x << " " << e1.y << endl;
    cout << "E2 " << e2.x << " " << e2.y << endl;
    int r = 27;
    struct coord c1 = mult(r, e1, p);
    cout << "C1 " << c1.x << " " << c1.y << endl;
    cout<<"\n Enter the number of test case: "; int t;  cin>>t;
    for(int i=0;i<t;i++){
    cout<<"\nENter Coordinates: ";
    cin >> plain.x >> plain.y;
    struct coord c2 = addn(plain, mult(r, e2, p), p);
    cout << "C2 " << c2.x << " " << c2.y << endl;
    struct coord decr = addn(c2, mult(-1, mult(d, c1, p), p), p);
    cout << "Decrypted " << ((decr.x >= 0) ? (decr.x) : (p + decr.x)) << " " << ((decr.y >= 0) ? (decr.y) : (p + decr.y)) << endl;
    }
    return 0;
}

S-DES
#include <bits/stdc++.h>
using namespace std;

vector<int> permute(vector<int>& key, vector<int>& permutation_key){
    vector<int> ret(permutation_key.size());
    for(int i=0; i<permutation_key.size(); ++i)
        ret[i] = key[permutation_key[i] - 1];
    return ret;
}

vector<int> circular_shift(vector<int>& permutation_key, int shift){
    int n = permutation_key.size();
    int lim = n / 2;
    vector<int> ret(n);
    for(int i=0; i<lim; ++i)
        ret[(i-shift+lim)%lim] = permutation_key[i];
    for(int i=0; i<lim; ++i)
        ret[lim + (i-shift+lim)%lim] = permutation_key[lim + i];
    return ret;
}

vector<int> expand(vector<int>& plain_text){
    vector<int> expansion_key = {4, 1, 2, 3, 2, 3, 4, 1};
    vector<int> ret(expansion_key.size());
    int lim = plain_text.size() / 2;
    for(int i=0; i<expansion_key.size(); ++i)
        ret[i] = plain_text[lim + expansion_key[i] - 1];
    return ret;
}

vector<int> apply_xor(vector<int>& lhs, vector<int>& rhs, int lim){
    vector<int> ret(lhs);
    for(int i=0; i<lim; ++i)
        ret[i] = lhs[i] ^ rhs[i];
    return ret;
}

void apply_swap(vector<int>& text){
    int n = text.size();
    int lim = n / 2;
    for(int i=0; i<lim; ++i)
        swap(text[i],text[lim+i]);
}

int value(int bit1, int bit2){
    int ret = 0;
    if(bit2)
        ret |= 1;
    if(bit1)
        ret |= 2;
    return ret;
}

vector<int> f_output(vector<int>& key, vector<vector<int> >& s0, vector<vector<int> >& s1){
    vector<int> ret;
    int r = value(key[0],key[3]);
    int c = value(key[1],key[2]);
    int val = s0[r][c];
    ret.push_back((int)(val>>1 & 1));
    ret.push_back((int)(val & 1));
    r = value(key[4],key[7]);
    c = value(key[5],key[6]);
    val = s1[r][c];
    ret.push_back((int)(val>>1 & 1));
    ret.push_back((int)(val & 1));
    return ret;
}

void fkey(vector<int>& plain_text, vector<int>& key){
    vector<vector<int> > s0 = {{1, 0, 3, 2}, {3, 2, 1, 0}, {0, 2, 1, 3}, {3, 1, 3, 2}};
    vector<vector<int> > s1 = {{0, 1, 2, 3}, {2, 0, 1, 3}, {3, 0, 1, 0}, {2, 1, 0, 3}};
    vector<int> p4 = {2, 4, 3, 1};
    int n = plain_text.size();
    vector<int> temp = expand(plain_text);
    vector<int> fkey = apply_xor(temp,key,n);
    vector<int> f = f_output(fkey,s0,s1);
    f = permute(f,p4);
    plain_text = apply_xor(plain_text,f,n/2);
}

int main() {
    int n = 8;
    int k = 10;
    vector<int> plain_text(n);
    vector<int> cipher_text;
    vector<int> decipher_text;
    vector<int> cipher_key(k);
    for(int i=0; i<n; ++i)
        cin>>plain_text[i];
    for(int i=0; i<k; ++i)
        cin>>cipher_key[i];
    // Initial Permutation
    vector<int> ip = {2, 6, 3, 1, 4, 8, 5, 7};
    plain_text = permute(plain_text,ip);

    // Key Generation
    vector<int> p10 = {3, 5, 2, 7, 4, 10, 1, 9, 8, 6};
    vector<int> p8 = {6, 3, 7, 4, 8, 5, 10, 9};
    vector<int> key_1, key_2;
    key_1 = permute(cipher_key,p10);
    key_1 = circular_shift(key_1,1);
    key_2 = circular_shift(key_1,2);
    key_1 = permute(key_1,p8);
    key_2 = permute(key_2,p8);
    cout<<"KEY1 = ";
    for(int i=0; i<key_1.size(); ++i)
        cout<<key_1[i]<<" ";
    cout<<endl;
    cout<<"KEY2 = ";
    for(int i=0; i<key_1.size(); ++i)
        cout<<key_2[i]<<" ";
    cout<<endl;

    // Apply f_k1
    fkey(plain_text,key_1);

    // Swap left and right parts
    apply_swap(plain_text);

    // Apply f_k2
    fkey(plain_text,key_2);

    // Final Permutation
    vector<int> fip = {4, 1, 3, 5, 7, 2, 8, 6};
    plain_text = permute(plain_text,fip);

    // Print final output
    for(int i=0; i<plain_text.size(); ++i)
        cout<<plain_text[i]<<" ";
    cout<<endl;

    plain_text = permute(plain_text,ip);
    fkey(plain_text,key_2);
    apply_swap(plain_text);
    fkey(plain_text,key_1);
    plain_text = permute(plain_text,fip);
    for(int i=0; i<plain_text.size(); ++i)
        cout<<plain_text[i]<<" ";
    cout<<endl;
    return 0;
}

//END OF FILE


/////////////////////////////////////////////ALL THE BEST//////////////////////////////////////////////////////////////