OOP project report cipher c++ .docx

Department of Computer Sciences
Bahria University, Islamabad Campus
`
Object Oriented Programming
Project Report
Assignment # 4
(Project-Part II)
This is a Group Assignment of maximum 3 students. Students can also work
alone. Prepare Project Report including project description, features, source
code, and screen shots of outcome and submit on time. Report should be
properly formatted and should adhere to formal English.

Contents
Introduction:.............................................................................................................................. 3
Project Topic: ......................................................................................................................... 3
Section:................................................................................................................................... 3
Group Members:..................................................................................................................... 3
Project Description ..................................................................................................................... 3
Intro:...................................................................................................................................... 3
Overview: ............................................................................................................................... 3
Features ..................................................................................................................................... 3
1. Caesar Cipher:................................................................................................................ 3
2. Substitution Cipher:........................................................................................................ 3
3. Reverse Cipher: .............................................................................................................. 4
4. Biliteral Cipher:.............................................................................................................. 4
Functionality: ............................................................................................................................. 4
Implementation Details:.............................................................................................................. 4
Classes:................................................................................................................................... 4
1.1 Caesar Cipher:............................................................................................................ 4
1.2 Subtitution Cipher: ..................................................................................................... 5
1.3 Reverse Cipher: .......................................................................................................... 5
1.4 Biliteral cipher: ........................................................................................................... 5
Source Code ............................................................................................................................... 5
Output: .....................................................................................................................................42
Selecting: ...............................................................................................................................42
Picking shift:..........................................................................................................................42
Encrypting:............................................................................................................................43
Decrypting:............................................................................................................................43
Loop:.....................................................................................................................................44
File Handling:........................................................................................................................44
Encrypted..............................................................................................................................44

Introduction:
Project Topic:
Cryptic Vault: Encrypt/decrypt security secrets with Cryptography.
Section:
BS(CS)-2A
Group Members:
Abdul Wasay (01-134232-012).
Muhammad Bilal (01-134232-115).
Shafay Mirza (01-134232-131).
Project Description
Intro:
Secure-Vault is an easy-to-use command-line tool for encrypting and decrypting
messages with different ciphers, including custom formulas. It helps you protect
sensitive information and decode encrypted messages simply and effectively.
Overview:
This project implements various classical ciphers in C++ including Caesar,
Substitution, Reverse, Biliteral and Multiplicative ciphers. It allows users to encrypt
and decrypt messages using different methods.
Features
1. Caesar Cipher:
 Provides encryption and decryption with shifts of 3, 7, 13, and custom user-
defined shifts.
2. Substitution Cipher:
 Uses a predefined substitution map for encryption and decryption of
messages.

3. Reverse Cipher:
 Encrypts text by reversing it and decrypts text by reversing the encrypted
message.
4. Biliteral Cipher:
 Encodes and decodes text using a mapping of characters to binary
representations.
Functionality:
 Users can choose which cipher to use, whether to encrypt or decrypt, and the
specific parameters (shifts, text inputs).
 The program includes colorful console outputs for clarity and user interaction
which has been done with the help of windows.h library.
 The program has used iomanip library which helps the code to be in proper
sequence.
 The code also does file handling with the help of fstream library.
 We have used map library which allows you to use the map container. A map
is an associative container that stores elements in key-value pairs, where each
key is unique. It provides efficient retrieval, insertion, and deletion operations
based on keys.
 The program runs in a loop, allowing users to perform multiple operations
without restarting.
Implementation Details:
Classes:
1.1 Caesar Cipher:
 CaesarCipher_encryption: Base class for Caesar cipher encryption.
 Cipher1, Cipher2, Cipher3, CipherCustom: Subclasses of
CaesarCipher_encryption with different shift values.
 CaesarCipher_decryption: Base class for Caesar cipher decryption.

 Cipher4, Cipher5, Cipher6, CipherCustomDecryption: Subclasses of
CaesarCipher_decryption for decryption with different shifts.
1.2 Subtitution Cipher:
 SubstitutionCipher: Implements substitution cipher encryption and
decryption.
1.3 Reverse Cipher:
 ReverseCipherEncryption, ReverseCipherDecryption: Classes for reverse
cipher encryption and decryption.
1.4 Biliteral cipher:
 BaconCipher(Biliteral cipher): Implements Bacon cipher encoding and
decoding.
Source Code
#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>
#include <map>
#include <algorithm>
#include <iomanip> // Aligning
#include <unordered_map>
using namespace std;
//*****************************************************************
******************************************************************
**************
// Parent Class

class CaesarCipher_encryption
{
protected:
int shift;
public:
CaesarCipher_encryption(int s) : shift(s % 26) {}
void SetConsoleTextColor(int textColor)
{
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hConsole, textColor);
}
string encrypt(const string& text)
{
string result = "";
for (char ch : text)
{
if (isupper(ch))
{
result += char(int(ch + shift - 65) % 26 + 65);
}
else if (islower(ch))
{
result += char(int(ch + shift - 97) % 26 + 97);

}
else
{
result += ch; // Non-alphabetic characters remain unchanged
}
}
return result;
}
};
// Child class with shift 3
class Cipher1 : public CaesarCipher_encryption
{
public:
Cipher1() : CaesarCipher_encryption(3) {}
void SetCursorPosition(int x, int y) {
COORD position = { static_cast<SHORT>(x), static_cast<SHORT>(y) };
SetConsoleCursorPosition(hConsole, position);
}
string input()
{
string text;
SetConsoleTextColor(12);

cout << setw(66) << "Enter Text for Cipher 1: ";
cin.ignore(); // Clear the buffer
getline(cin, text);
return text;
}
};
{
public:
}
string input()
{
string text;

getline(cin, text);
return text;
}
};
{
public:
}
string input()
{
string text;
getline(cin, text);

return text;
}
};
// Child class with user-defined shift
class CipherCustom : public CaesarCipher_encryption
{
public:
CipherCustom(int shift) : CaesarCipher_encryption(shift) {}
}
string input()
{
string text;
cout << setw(71) << "Enter Text for Custom Cipher: ";
getline(cin, text);
return text;
}

};
//*****************************************************************
******************************************************************
*************
class CaesarCipher_decryption
{
protected:
int shift;
public:
{
}
string decrypt(const string& a, int shift)
{
string result = a;
for (char& c : result)
{
if (isalpha(c))
{
char base = islower(c) ? 'a' : 'A';
c = (c - base - shift + 26) % 26 + base;

}
}
return result;
}
};
class Cipher4 : public CaesarCipher_decryption
{
public:
Cipher4() : CaesarCipher_decryption() {}
}
string input()
{
string text;
cout << setw(66) << "Enter Text for Cipher_3: ";
getline(cin, text);
return text;

}
};
{
public:
}
string input()
{
string text;
getline(cin, text);
return text;
}
};

{
public:
}
string input()
{
string text;
getline(cin, text);
return text;
}
};
class CipherCustomDecryption : public CaesarCipher_decryption
{
public:
CipherCustomDecryption() : CaesarCipher_decryption() {}

}
string input()
{
string text;
cout << setw(75) << "Enter Text for Custom Decryption: ";
getline(cin, text);
return text;
}
};
//*****************************************************************
******************************************************************
**************
//Substitution cipher
class SubstitutionCipher
{
public:

map<char, char> encryptionMap;
map<char, char> decryptionMap;
SubstitutionCipher(map<char, char> map)
{
encryptionMap = map;
for (const auto& pair : map)
decryptionMap[pair.second] = pair.first;
}
string encrypt(const string& plaintext)
{
string ciphertext;
for (char c : plaintext)
{
if (encryptionMap.find(c) != encryptionMap.end())
{
ciphertext += encryptionMap[c];
}
else
{
ciphertext += c; // keep non-alphabetic characters unchanged
}
}
return ciphertext;

}
string decrypt(const string& ciphertext)
{
string decryptedText;
for (char c : ciphertext)
{
if (decryptionMap.find(c) != decryptionMap.end())
{
decryptedText += decryptionMap[c];
}
else
{
decryptedText += c; // keep non-alphabetic characters unchanged
}
}
return decryptedText;
}
};
//*****************************************************************
******************************************************************
**************
//Reverse Cipher
class ReverseCipherDecryption; // Forward declaration

class ReverseCipherEncryption
{
public:
string encrypt(const string& plainText)
{
string cipherText = plainText;
reverse(cipherText.begin(), cipherText.end());
return cipherText;
}
};
class ReverseCipherDecryption
{
public:
string decrypt(const string& cipherText)
{
string plainText = cipherText;
reverse(plainText.begin(), plainText.end());
return plainText;
}
friend string decryptUsingFriend(const ReverseCipherDecryption& dec, const
string& cipherText);
};
class UserInput

{
public:
{
}
string getInput(const string& prompt)
{
string input;
cout << prompt;
getline(cin, input);
return input;
}
};
void SetConsoleTextColor(int color)
{
// Function to set console text color for Windows
SetConsoleTextAttribute(hConsole, color);
}

void WriteToFile(const string& filename, const string& encryptedText)
{
ofstream outFile(filename, ios::binary); // Open file in binary mode
if (outFile.is_open())
{
outFile.write(encryptedText.c_str(), encryptedText.size());
outFile.close();
}
else
{
cout << "Unable to open file: " << filename << endl;
}
}
string ReadFromFile(const string& filename)
{
string encryptedText;
ifstream inFile(filename, ios::binary); // Open file in binary mode
if (inFile.is_open())
{
inFile.seekg(0, ios::end);
int fileSize = inFile.tellg();
inFile.seekg(0, ios::beg);

char* buffer = new char[fileSize];
inFile.read(buffer, fileSize);
encryptedText.assign(buffer, fileSize);
delete[] buffer;
inFile.close();
}
else
{
cout << "Unable to open file: " << filename << endl;
}
return encryptedText;
}
string decryptUsingFriend(const ReverseCipherDecryption& dec, const string&
cipherText)
{
string plainText = cipherText;
reverse(plainText.begin(), plainText.end());
return plainText;
}
// Function to set cursor position

}
//*****************************************************************
******************************************************************
*************
//Biliteral Cipher
class BaconCipher
{
private:
unordered_map<char, string> baconMap;
unordered_map<string, char> reverseBaconMap;
void initializeBaconCipher()
{
string baconCodes[26] =
{
"aaaaa", "aaaab", "aaaba", "aaabb", "aabaa", "aabab", "aabba", "aabbb",
"abaaa", "abaab", "ababa", "ababb", "abbaa", "abbab", "abbba", "abbbb",
"baaaa", "baaab", "baaba", "baabb", "babaa", "babab", "babba", "babbb",
"bbaaa", "bbaab"
};
for (char c = 'A'; c <= 'Z'; ++c)
{

baconMap[c] = baconCodes[c - 'A'];
reverseBaconMap[baconCodes[c - 'A']] = c;
}
}
public:
BaconCipher()
{
initializeBaconCipher();
}
string encode(const string& plaintext)
{
string encodedText;
for (char c : plaintext)
{
if (isalpha(c))
{
encodedText += baconMap[toupper(c)];
}
}
return encodedText;
}
string decode(const string& encodedText)
{

string decodedText;
for (size_t i = 0; i < encodedText.size(); i += 5)
{
string segment = encodedText.substr(i, 5);
if (reverseBaconMap.find(segment) != reverseBaconMap.end())
{
decodedText += reverseBaconMap[segment];
}
}
return decodedText;
}
};
//*****************************************************************
******************************************************************
**************
int main()
{
const int colors[] =
{
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15
};
// Color names corresponding to the color codes

const char* colorNames[] =
{
"Black", "Blue", "Green", "Aqua", "Red", "Purple", "Yellow", "White",
"Gray", "Light Blue", "Light Green", "Light Aqua", "Light Red", "Light
Purple", "Light Yellow", "Bright White"
};
cout << fixed << setw(85) << " Cryptic Vault" << endl << endl;
cout << fixed << setw(93) << " Wellcome To Cipher World <3" << endl;
char Z;
do {
int a;
cout << "Choose one of the below: " << endl;
cout << "1.Ceasar Cipher " << endl;
cout << "2.Substitution Cipher " << endl;
cout << "3.Reverse Cipher " << endl;
cout << "4.Biliteral Cipher " << endl;
cout << "Enter your choice: ";
cin >> a;

cout << endl;
switch (a)
{
case 1: // Ceasar Cipher
{
int b;
cout << setw(40) << "Choose one of the below: " << endl;
cout << setw(32) << "1.For encryption" << endl;
cout << setw(32) << "2.For decryption" << endl;
cout << setw(35) << "Enter your choice: ";
cin >> b;
cout << endl;
switch (b)
{
case 1:
{
int c;

cout << setw(65) << "1.For encryption with shift 3." << endl;
cout << setw(76) << "4.For encryption with user defined shift." << endl;
cin >> c;
cout << endl;
switch (c)
{
case 1:
{
Cipher1 cipher1;
string text1 = cipher1.input();
string encrypted1 = cipher1.encrypt(text1);
cout << setw(66) << "Encrypted with Cipher_3: ";
cout << encrypted1 << endl;
break;
}

case 2:
{
Cipher2 cipher2;
break;
}
case 3:
{
Cipher3 cipher3;
break;
}
case 4:

{
int shift;
cout << setw(64) << "Enter the shift value: ";
cin >> shift;
CipherCustom cipherCustom(shift);
string textCustom = cipherCustom.input();
string encryptedCustom = cipherCustom.encrypt(textCustom);
cout << setw(63) << "Encrypted with Cipher_" << shift << ": ";
cout << encryptedCustom << endl;
break;
}
default:
{
cout << "Invalid Number! Please choose a correct number for
encryption." << endl;
break;
}
}
break;

}
case 2:
{
int d;
cout << setw(65) << "1.for decryption with shift 3." << endl;
cout << setw(76) << "4.for decryption with user defined shift." << endl;
cin >> d;
cout << endl;
switch (d)
{
case 1:
{
Cipher4 cipher4;
string decrypted4 = cipher4.decrypt(text4, 3);

cout << setw(66) << "Decrypted with Cipher_3: ";
cout << decrypted4 << endl;
break;
}
case 2:
{
Cipher5 cipher5;
break;
}
case 3:
{
Cipher6 cipher6;

break;
}
case 4:
{
int shift;
cout << setw(64) << "Enter the shift value: ";
cin >> shift;
CipherCustomDecryption cipherCustomDecryption;
string textCustom = cipherCustomDecryption.input();
string decryptedCustom =
cipherCustomDecryption.decrypt(textCustom, shift);
cout << setw(63) << "Decrypted with Cipher_" << shift << ": ";
cout << decryptedCustom << endl;
break;
}
default:

{
decryption." << endl;
break;
}
}
break;
}
default:
{
cout << "Invalid Number! Choose correct number for Ceasar
encryption/decryption." << endl;
break;
}
}
break;
}
case 2: //Substitutionl Cipher
{
map<char, char> substitutionMap =
{

{'a', 'q'}, {'b', 'w'}, {'c', 'e'}, {'d', 'r'}, {'e', 't'},
{'f', 'y'}, {'g', 'u'}, {'h', 'i'}, {'i', 'o'}, {'j', 'p'},
{'k', 'a'}, {'l', 's'}, {'m', 'd'}, {'n', 'f'}, {'o', 'g'},
{'p', 'h'}, {'q', 'j'}, {'r', 'k'}, {'s', 'l'}, {'t', 'z'},
{'u', 'x'}, {'v', 'c'}, {'w', 'v'}, {'x', 'b'}, {'y', 'n'},
{'z', 'm'}
};
SubstitutionCipher cipher(substitutionMap);
int e;
cout << setw(32) << "1.For encryption" << endl;
cout << setw(32) << "2.For decryption" << endl;
cin >> e;
cout << endl;
cin.ignore(); // ignore the newline character in the input buffer
string text;
if (e == 1)
{

cout << setw(49) << "Enter the text to encrypt: ";
getline(cin, text);
cout << setw(38) << "Encrypted text: ";
cout << cipher.encrypt(text) << endl;
}
else if (e == 2)
{
cout << setw(49) << "Enter the text to decrypt: ";
getline(cin, text);
cout << setw(38) << "Decrypted text: ";
cout << cipher.decrypt(text) << endl;
}
else
{

Substitutional encryption/decryption.";
}
break;
}
case 3: // Reverse Cipher
{
int f;
cout << setw(32) << "1. For encryption" << endl;
cout << setw(32) << "2. For decryption" << endl;
cin >> f;
cin.ignore(); // Ignore newline character left in the buffer
cout << endl;
switch (f)
{
case 1:

{
ReverseCipherEncryption encryptor;
UserInput userInput;
string plainText = userInput.getInput("tttEnter text to encrypt: ");
string cipherText = encryptor.encrypt(plainText);
cout << setw(37) << "Cipher Text: ";
cout << cipherText << endl;
WriteToFile("encrypted.txt", cipherText);
break;
}
case 2:
{
ReverseCipherDecryption decryptor;
UserInput userInput;
string cipherText = userInput.getInput("tttEnter text to decrypt: ");
string plainText = decryptor.decrypt(cipherText);
cout << setw(37) << "Plain Text: ";
WriteToFile("decrypted.txt", plainText);

cout << plainText << endl;
WriteToFile("decrypted.txt", plainText);
break;
}
default:
{
cout << "Invalid Number! Choose correct number for Reverse
break;
}
}
}
break;
case 4:
{
BaconCipher cipher;
string inputText;
int g;
cout << setw(32) << "1.for encryption" << endl;

cout << setw(32) << "2.for decryption" << endl;
cin >> g;
cout << endl;
cin.ignore();
switch (g)
{
case 1:
{
cout << setw(48) << "Enter the text to encode: ";
getline(cin, inputText);
string encodedText = cipher.encode(inputText);
cout << setw(36) << "Encoded Text: ";
cout << encodedText << endl;
break;
}
case 2:

{
cout << setw(48) << "Enter the text to decode: ";
getline(cin, inputText);
string decodedText = cipher.decode(inputText);
cout << setw(36) << "Decoded Text: ";
cout << decodedText << endl;
break;
}
default:
{
cout << "Invalid Number! Please choose a correct number bileteral for
break;
}
}
break;
}
default:

{
cout << "Invalid Number! Choose correct number for
encryption/decryption of different Ciphers :)" << endl;
break;
}
}
cout << endl;
cout << "Do you want to run the program again? (y/n): ";
cin >> Z;
cout << endl;
} while (Z == 'Y' || Z == 'y');
cout << "Program Executed." << endl;
}

Output:
Selecting:
Picking shift:

Loop:
File Handling:
Encrypted Decrypted

We further have the plans to use file handling and for advance level. In which
complete files will get encrypted and decrypted respectively. Storing data in
new files and their encryption/decryption.
The End 😊

OOP project report cipher c++ .docx

More Related Content

Similar to OOP project report cipher c++ .docx

Recently uploaded

OOP project report cipher c++ .docx