Additive, Multiplicative & Affine Ciphers
#include <iostream>
#include <string>
using namespace std;
string additiveCipherEncrypt(string message, int key) {
string encrypted_message = "";
for (char& c : message) {
if (isalpha(c)) {
char shift = isupper(c) ? 'A' : 'a';
c = ((c - shift + key) % 26 + 26) % 26 + shift;
}
encrypted_message += c;
}
return encrypted_message;
}
string additiveCipherDecrypt(string message, int key) {
return additiveCipherEncrypt(message, -key);
}
int multiplicativeInverse(int a, int m) {
a = a % m;
for (int x = 1; x < m; x++) {
if ((a * x) % m == 1) {
return x;
}
}
return 1;
}
string multiplicativeCipherEncrypt(string message, int key) {
string encrypted_message = "";
for (char& c : message) {
if (isalpha(c)) {
char shift = isupper(c) ? 'A' : 'a';
c = ((c - shift) * key % 26 + 26) % 26 + shift;
}
encrypted_message += c;
}
return encrypted_message;
}
string multiplicativeCipherDecrypt(string message, int key) {
int inv_key = multiplicativeInverse(key, 26);
string decrypted_message = "";
for (char& c : message) {
if (isalpha(c)) {
char shift = isupper(c) ? 'A' : 'a';
c = ((c - shift) * inv_key % 26 + 26) % 26 + shift;
}
decrypted_message += c;
}
return decrypted_message;
}
string affineCipherEncrypt(string message, int key1, int key2) {
string encrypted_message = "";
for (char& c : message) {
if (isalpha(c)) {
char shift = isupper(c) ? 'A' : 'a';
c = ((c - shift) * key1 + key2) % 26 + shift;
}
encrypted_message += c;
}
return encrypted_message;
}
string affineCipherDecrypt(string message, int key1, int key2) {
int inv_key1 = multiplicativeInverse(key1, 26);
string decrypted_message = "";
for (char& c : message) {
if (isalpha(c)) {
char shift = isupper(c) ? 'A' : 'a';
c = (inv_key1 * ((c - shift - key2 + 26) % 26)) % 26 + shift;
}
decrypted_message += c;
}
return decrypted_message;
}
void cipherMenu() {
int choice;
string message;
int key1, key2;
cout << "Cipher Menu:\n";
cout << "1. Additive Cipher Encrypt\n";
cout << "2. Additive Cipher Decrypt\n";
cout << "3. Multiplicative Cipher Encrypt\n";
cout << "4. Multiplicative Cipher Decrypt\n";
cout << "5. Affine Cipher Encrypt\n";
cout << "6. Affine Cipher Decrypt\n";
cout << "7. Exit\n";
cout << "Enter your choice: ";
cin >> choice;
cin.ignore(); // Clear the newline character from the buffer
if (choice >= 1 && choice <= 6) {
cout << "Enter message: ";
getline(cin, message);
}
switch (choice) {
case 1:
cout << "Enter key: ";
cin >> key1;
cout << "Encrypted Message: " << additiveCipherEncrypt(message, key1) << endl;
break;
case 2:
cout << "Enter key: ";
cin >> key1;
cout << "Decrypted Message: " << additiveCipherDecrypt(message, key1) << endl;
break;
case 3:
cout << "Enter key: ";
cin >> key1;
cout << "Encrypted Message: " << multiplicativeCipherEncrypt(message, key1) <<
endl;
break;
case 4:
cout << "Enter key: ";
cin >> key1;
cout << "Decrypted Message: " << multiplicativeCipherDecrypt(message, key1) <<
endl;
break;
case 5:
cout << "Enter key1: ";
cin >> key1;
cout << "Enter key2: ";
cin >> key2;
cout << "Encrypted Message: " << affineCipherEncrypt(message, key1, key2) <<
endl;
break;
case 6:
cout << "Enter key1: ";
cin >> key1;
cout << "Enter key2: ";
cin >> key2;
cout << "Decrypted Message: " << affineCipherDecrypt(message, key1, key2) <<
endl;
break;
case 7:
cout << "Exiting..." << endl;
break;
default:
cout << "Invalid choice! Please try again." << endl;
}
}
int main() {
int choice;
do {
cipherMenu();
cout << "Do you want to continue? (1 for yes, 0 for no): ";
cin >> choice;
} while (choice != 0);
return 0;
}
Row & Column Transposition Cipher
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
// Function prototypes
string encryptRowTransposition(string message, string key);
string decryptRowTransposition(string message, string key);
string encryptColumnTransposition(string message, string key);
string decryptColumnTransposition(string message, string key);
int main() {
int choice;
string message, key;
do {
cout << "===== Transposition Cipher Menu =====" << endl;
cout << "1. Row Transposition Encryption" << endl;
cout << "2. Row Transposition Decryption" << endl;
cout << "3. Column Transposition Encryption" << endl;
cout << "4. Column Transposition Decryption" << endl;
cout << "5. Exit" << endl;
cout << "Enter your choice: ";
cin >> choice;
if (choice >= 1 && choice <= 4) {
cout << "Enter message: ";
cin.ignore();
getline(cin, message);
cout << "Enter key: ";
getline(cin, key);
switch (choice) {
case 1:
cout << "Encrypted Message (Row Transposition): "
<< encryptRowTransposition(message, key) << endl;
break;
case 2:
cout << "Decrypted Message (Row Transposition): "
<< decryptRowTransposition(message, key) << endl;
break;
case 3:
cout << "Encrypted Message (Column Transposition): "
<< encryptColumnTransposition(message, key) << endl;
break;
case 4:
cout << "Decrypted Message (Column Transposition): "
<< decryptColumnTransposition(message, key) << endl;
break;
case 5:
cout << "Exiting..." << endl;
break;
default:
cout << "Invalid choice. Please try again." << endl;
} while (choice != 5);
return 0;
}
// Row Transposition Encryption
string encryptRowTransposition(string message, string key) {
int columns = key.length();
int rows = (message.length() + columns - 1) / columns;
message += string(rows * columns - message.length(), 'X');
string encrypted = "";
for (char col : key) {
int colIndex = col - '1';
for (int row = 0; row < rows; ++row) {
encrypted += message[row * columns + colIndex];
return encrypted;
// Row Transposition Decryption
string decryptRowTransposition(string message, string key) {
int columns = key.length();
int rows = message.length() / columns;
vector<string> grid(rows, string(columns, ' '));
int k = 0;
for (char col : key) {
int colIndex = col - '1';
for (int row = 0; row < rows; ++row) {
grid[row][colIndex] = message[k++];
string decrypted = "";
for (int row = 0; row < rows; ++row) {
decrypted += grid[row];
return decrypted;
// Column Transposition Encryption
string encryptColumnTransposition(string message, string key) {
int columns = key.length();
int rows = (message.length() + columns - 1) / columns;
message += string(rows * columns - message.length(), 'X');
vector<string> grid(rows, string(columns, ' '));
int k = 0;
for (int row = 0; row < rows; ++row) {
for (int col = 0; col < columns; ++col) {
grid[row][col] = message[k++];
}
string encrypted = "";
vector<pair<char, int>> keyOrder;
for (int i = 0; i < columns; ++i) {
keyOrder.push_back({key[i], i});
sort(keyOrder.begin(), keyOrder.end());
for (auto& [ch, col] : keyOrder) {
for (int row = 0; row < rows; ++row) {
encrypted += grid[row][col];
return encrypted;
// Column Transposition Decryption
string decryptColumnTransposition(string message, string key) {
int columns = key.length();
int rows = message.length() / columns;
vector<string> grid(rows, string(columns, ' '));
vector<pair<char, int>> keyOrder;
for (int i = 0; i < columns; ++i) {
keyOrder.push_back({key[i], i});
sort(keyOrder.begin(), keyOrder.end());
int k = 0;
for (auto& [ch, col] : keyOrder) {
for (int row = 0; row < rows; ++row) {
grid[row][col] = message[k++];
string decrypted = "";
for (int row = 0; row < rows; ++row) {
decrypted += grid[row];
return decrypted;
A5/1 stream Cipher
#include <iostream>
#include <string>
#include <bitset>
#include <vector>
using namespace std;
// Function to XOR two binary strings
string xorStrings(const string &a, const string &b) {
string result = "";
for (size_t i = 0; i < a.size(); i++) {
result += (a[i] == b[i]) ? '0' : '1';
return result;
// Function to perform a shift on a register based on feedback taps
string shiftRegister(const string ®isterStr, const vector<int> &taps) {
int feedback = 0;
for (int tap : taps) {
feedback ^= (registerStr[tap] - '0'); // XOR the tapped positions
return to_string(feedback) + registerStr.substr(0, registerStr.size() - 1); // Shift left and add feedback
// Function to generate the keystream using A5/1 algorithm
string generateKeystream(const string &key) {
// Initialize the registers
string reg1 = key.substr(0, 19);
string reg2 = key.substr(19, 22);
string reg3 = key.substr(41, 23);
// A5/1 taps
vector<int> taps1 = {8, 10, 13, 16}; // Taps for 19-bit register
vector<int> taps2 = {10, 12, 13}; // Taps for 22-bit register
vector<int> taps3 = {10, 12, 13}; // Taps for 23-bit register
string keystream = "";
for (int i = 0; i < 100; i++) {
// Majority rule: count the number of 1's in positions
int majority = (reg1[8] - '0') + (reg2[10] - '0') + (reg3[10] - '0');
// Shift registers based on the majority rule
if (majority >= 2) {
reg1 = shiftRegister(reg1, taps1);
if (majority <= 1) {
reg2 = shiftRegister(reg2, taps2);
if (reg3[13] == '1') {
reg3 = shiftRegister(reg3, taps3);
// Generate keystream bit by XORing the last bits of each register
keystream += to_string((reg1[18] - '0') ^ (reg2[21] - '0') ^ (reg3[22] - '0'));
return keystream;
// Function to encrypt/decrypt a message using A5/1 algorithm
string encryptDecrypt(const string &message, const string &key) {
// Generate the keystream
string keystream = generateKeystream(key);
// Ensure the message is in binary format
string messageBin = "";
for (char ch : message) {
messageBin += bitset<8>(ch).to_string();
// XOR the message with the keystream
return xorStrings(messageBin, keystream);
int main() {
string key, message;
cout << "Enter a 64-bit binary key: ";
cin >> key;
// Ensure the key is 64 bits
if (key.length() != 64) {
cout << "Key must be 64 bits long." << endl;
return 1;
cout << "Enter the message: ";
cin.ignore();
getline(cin, message);
// Encrypt the message
string encryptedMessage = encryptDecrypt(message, key);
cout << "Encrypted Message (in binary): " << encryptedMessage << endl;
// Decrypt the message (same as encryption)
string decryptedMessageBin = encryptDecrypt(encryptedMessage, key);
// Convert decrypted binary message back to text
string decryptedMessage = "";
for (size_t i = 0; i < decryptedMessageBin.length(); i += 8) {
string byte = decryptedMessageBin.substr(i, 8);
char character = static_cast<char>(bitset<8>(byte).to_ulong());
decryptedMessage += character;
}
cout << "Decrypted Message: " << decryptedMessage << endl;
return 0;
RSA-1
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
// Function to compute greatest common divisor (GCD)
long long gcd(long long a, long long b) {
while (b != 0) {
long long t = b;
b = a % b;
a = t;
return a;
}
// Function to compute modular inverse using extended Euclidean algorithm
long long modInverse(long long a, long long m) {
long long m0 = m, t, q;
long long x0 = 0, x1 = 1;
if (m == 1) return 0;
while (a > 1) {
q = a / m;
t = m;
m = a % m;
a = t;
t = x0;
x0 = x1 - q * x0;
x1 = t;
if (x1 < 0) x1 += m0;
return x1;
// Function to generate RSA keys with user input for p and q
void generateRSAKeys(long long &n, long long &e, long long &d) {
long long p, q;
// User input for prime numbers
cout << "Enter a prime number p: ";
cin >> p;
cout << "Enter a prime number q: ";
cin >> q;
// Check if p and q are primes (this is just a basic check, for larger primes you would need more robust
methods)
if (p <= 1 || q <= 1) {
cout << "Both numbers must be prime and greater than 1. Exiting.\n";
exit(1);
n = p * q; // n = p * q
long long phi = (p - 1) * (q - 1); // phi = (p - 1) * (q - 1)
// Choose e such that 1 < e < phi and gcd(e, phi) = 1
e = 17; // e is commonly chosen as 17 in RSA (though it should be coprime with phi)
// Calculate d such that d * e ≡ 1 (mod phi)
d = modInverse(e, phi);
// Function to encrypt message using public key (e, n)
long long encrypt(long long message, long long e, long long n) {
long long encryptedMessage = 1;
// Encrypt: C = M^e mod n
for (long long i = 0; i < e; i++) {
encryptedMessage = (encryptedMessage * message) % n;
}
return encryptedMessage;
// Function to decrypt message using private key (d, n)
long long decrypt(long long encryptedMessage, long long d, long long n) {
long long decryptedMessage = 1;
// Decrypt: M = C^d mod n
for (long long i = 0; i < d; i++) {
decryptedMessage = (decryptedMessage * encryptedMessage) % n;
return decryptedMessage;
int main() {
long long n, e, d;
// Step 1: Generate RSA keys based on user input
generateRSAKeys(n, e, d);
cout << "Public Key (e, n): (" << e << ", " << n << ")\n";
cout << "Private Key (d, n): (" << d << ", " << n << ")\n";
// Step 2: Encrypt a message
long long message;
cout << "\nEnter a message (numeric value): ";
cin >> message;
if (message < 0 || message >= n) {
cout << "Message must be less than the value of n (" << n << "). Exiting program.\n";
return 1;
long long encryptedMessage = encrypt(message, e, n);
cout << "Encrypted Message: " << encryptedMessage << endl;
// Step 3: Decrypt the message
long long decryptedMessage = decrypt(encryptedMessage, d, n);
cout << "Decrypted Message: " << decryptedMessage << endl;
return 0;
RSA-2
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>
int gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
return a;
long long modExpo(long long base, long long exp, long long mod) {
long long result = 1;
while (exp > 0) {
if (exp % 2 == 1)
result = (result * base) % mod;
base = (base * base) % mod;
exp /= 2;
return result;
int modInverse(int e, int phi) {
int t1 = 0, t2 = 1, r1 = phi, r2 = e;
while (r2 > 0) {
int q = r1 / r2;
int t = t1 - q * t2;
t1 = t2;
t2 = t;
int r = r1 - q * r2;
r1 = r2;
r2 = r;
if (t1 < 0) {
t1 += phi;
return t1;
void generateKeys(int &n, int &e, int &d, int p, int q) {
n = p * q;
int phi = (p - 1) * (q - 1);
do {
e = rand() % (phi - 2) + 2;
} while (gcd(e, phi) != 1);
d = modInverse(e, phi);
int main() {
srand(time(0));
int p = 61, q = 53;
int n, e, d;
generateKeys(n, e, d, p, q);
std::cout << "Public Key: (" << e << ", " << n << ")" << std::endl;
std::cout << "Private Key: (" << d << ", " << n << ")" <<
std::endl;
int plainText = 89;
std::cout << "\nOriginal Plaintext: " << plainText << std::endl;
long long cipherText = modExpo(plainText, e, n);
std::cout << "Ciphertext: " << cipherText << std::endl;
long long decryptedText = modExpo(cipherText, d, n);
std::cout << "Decrypted Text: " << decryptedText << std::endl;
long long signature = modExpo(plainText, d, n);
std::cout << "\nSignature: " << signature << std::endl;
long long verifiedText = modExpo(signature, e, n);
std::cout << "Verified Text: " << verifiedText << std::endl;
return 0;
