Cryptography and Network Security
Caesar Ciphering Algorithm
Assignment
Tala Samer AlZaidi 202030040
Raghad Adel Hassan 202010306
1. Introduction:
This research aims to introduce a novel Vigenere encryption and decryption technique. A
basic polyalphabetic substitution technique is used in the Vigenere cipher to encrypt
alphabetic text. The technique is more secure than a typical Caesar cipher since it employs
a keyword to change the characters in the plaintext.
2. Problem Description and Limitations
2.1 Key Length Vulnerability
The Vigenere cipher's security is mostly reliant on the keyword's length. Short keywords
make the ciphertext more vulnerable to frequency analysis, which facilitates enemy
communication decryption.
2.2 Handling of Non-Alphabetical Characters
Non-alphabetical characters are not supported by the conventional Vigenere cipher, which
could expose plaintext patterns and weaken the encryption.
2.3 Proposed Solution Overview
An algorithm for dynamic key expansion is given in order to overcome these drawbacks. A
stronger encryption is ensured by this algorithm, which creates a longer key dependent on
the length of the plaintext. The Vigenere cipher's overall security is improved, and
weaknesses related to short keywords are lessened thanks to the dynamic key expansion.
3. Description of Your Solution (New Algorithm) using
Equation, Flow Chart, and Pseudocode
3.1 Algorithm Overview:
The proposed algorithm includes the following steps:
1. Dynamic Key Expansion: Generate a key that is as long as the plaintext by repeatedly
appending the original keyword.
2. Vigenere Encryption: Encrypt the plaintext using the generated dynamic key.
3. Vigenere Decryption: Decrypt the ciphertext using the same dynamic key.
3.2 Pseudocode:
function dynamicKeyExpansion(plaintext, keyword):
key = generateDynamicKey(plaintext, keyword)
ciphertext = vigenereEncrypt(plaintext, key)
return ciphertext
function generateDynamicKey(plaintext, keyword):
key = keyword
while key.length < plaintext.length:
key += keyword
return key.substr(0, plaintext.length)
function vigenereEncrypt(plaintext, key):
// Existing Vigenere encryption logic
// ...
function vigenereDecrypt(ciphertext, key):
// Existing Vigenere decryption logic
// ...
3.3 Flow Chart (High-Level)
Start of Program
Read Keyword & Text
Generate Dynamic Key
Vigenere Encryption
Write
Ciphered Text
Vigenere Decryption
Write
Deciphered
4. Your Code with Comments and Explanation
#include <iostream>
End
#include <fstream>
#include <string>
using namespace std;
// Function to perform Vigenere encryption with dynamic key expansion
string vigenereEncryptDynamic(string plaintext, string keyword) {
// Generate a key with dynamic key expansion
string key = generateDynamicKey(plaintext, keyword);
// Initialize variables
string ciphertext = "";
int keyLength = key.length();
int textLength = plaintext.length();
// Encryption loop
for (int i = 0; i < textLength; ++i) {
char currentChar = plaintext[i];
// Check if the character is an alphabet letter
if (isalpha(currentChar)) {
char base = islower(currentChar) ? 'a' : 'A';
char shiftBase = islower(key[i % keyLength]) ? 'a' : 'A';
// Perform encryption
char encryptedChar = static_cast<char>((currentChar - base + (key[i % keyLength] -
shiftBase)) % 26 + base);
ciphertext += encryptedChar;
} else {
ciphertext += currentChar; // Keep non-alphabetical characters unchanged
}
}
return ciphertext;
}
// Function to perform Vigenere decryption with dynamic key expansion
string vigenereDecryptDynamic(string ciphertext, string keyword) {
// Generate a key with dynamic key expansion
string key = generateDynamicKey(ciphertext, keyword);
// Initialize variables
string plaintext = "";
int keyLength = key.length();
int textLength = ciphertext.length();
// Decryption loop
for (int i = 0; i < textLength; ++i) {
char currentChar = ciphertext[i];
// Check if the character is an alphabet letter
if (isalpha(currentChar)) {
char base = islower(currentChar) ? 'a' : 'A';
char shiftBase = islower(key[i % keyLength]) ? 'a' : 'A';
// Perform decryption
char decryptedChar = static_cast<char>((currentChar - base - (key[i % keyLength] -
shiftBase) + 26) % 26 + base);
plaintext += decryptedChar;
} else {
plaintext += currentChar; // Keep non-alphabetical characters unchanged
}
}
return plaintext;
}
// Function to generate a key with dynamic key expansion
string generateDynamicKey(string text, string keyword) {
string key = keyword;
while (key.length() < text.length()) {
key += keyword;
}
return key.substr(0, text.length());
}
int main() {
// Read plaintext from file
ifstream inFile("plaintext.txt");
// Create files for ciphered and deciphered texts
ofstream cipherFile("cipheredtext.txt");
ofstream decipherFile("decipheredtext.txt");
// Set the keyword
string keyword = "raghad";
// Check if files are opened successfully
if (inFile.is_open() && cipherFile.is_open()) {
string plaintext;
// Read each line from the file and perform encryption
while (getline(inFile, plaintext)) {
string ciphertext = vigenereEncryptDynamic(plaintext, keyword);
cipherFile << ciphertext << endl;
}
// Close files
inFile.close();
cipherFile.close();
cout << "Ciphering successful!" << endl;
} else {
cout << "Unable to open files for ciphering!" << endl;
}
// Read ciphered text from file
ifstream cipherInFile("cipheredtext.txt");
// Check if files are opened successfully
if (cipherInFile.is_open() && decipherFile.is_open()) {
string ciphertext;
// Read each line from the file and perform decryption
while (getline(cipherInFile, ciphertext)) {
string decryptedtext = vigenereDecryptDynamic(ciphertext, keyword);
decipherFile << decryptedtext << endl;
}
// Close files
cipherInFile.close();
decipherFile.close();
cout << "Deciphering successful!" << endl;
} else {
cout << "Unable to open files for deciphering!" << endl;
}
return 0;
-The genereEncryptDynamic function uses dynamic key expansion to carry out Vigenere
encryption. It uses the generateDynamicKey function to create a dynamic key, encrypts the
plaintext, and receives the keyword as inputs.
-The Vigenere decryption with dynamic key expansion is carried out by the
vigenereDecryptDynamic function. It decrypts the ciphertext after generating a dynamic
key using the generateDynamicKey function with the ciphertext and keyword as inputs.
-The function GenerateDynamicKey creates a key with dynamic key expansion. The original
keyword is repeated until the text is the desired length, at which point the key is truncated
to fit the text.
-primary purpose: The primary function reads text from a file in plaintext, encrypts it using
Vigenere, writes the encrypted text to a file, retrieves the encrypted text from the file,
decrypts it using Vigenere, and writes the decoded content to a different file.
}
5. Your Design Constraints
5.1 Key Length
The suggested algorithm's security depends on choosing a sufficiently long, random term.
In order to increase the encryption strength, users are advised to select a strong keyword.
5.2 Computational Overhead
The extra key generation step in the dynamic key expansion could result in a little
computational overhead. For increased security, this is regarded as a fair trade-off,
nevertheless.
6. References
D. Singh, "Cryptography and Network Security," Tata McGraw-Hill Education, 2011.
