Cryptography & Information Security
A Lab Manual
Submitted in Partial Fulfillment of the Requirement for the Award of the Degree of
BACHELOR OF TECHNOLOGY
in
COMPUTER SCIENCE & ENGINEERING
SUBMITTED TO
Rajiv Gandhi Proudyogiki Vishwavidyalaya Bhopal (M.P.)
SUBMITTED BY
Amit Bhattacharya (Enrollment No.: 0176CS201027)
Lakshmi Narain College of Technology Excellence, Bhopal (M.P.), India
UNDER THE SUPERVISION OF
Prof. Kirti Verma
Professor, Department of Computer Science & Engineering
Lakshmi Narain College of Technology Excellence, Bhopal (M.P.)
India
Department of Computer Science & Engineering
Lakshmi Narain College of Technology Excellence, Bhopal (M.P.)
Session: December 2023
LIST OF EXPERIMENTS
SERIAL NO. NAME OF EXPERIMENT DATE OF
SUBMISSION
1 Implementation of Block Cipher and Play Fair Cipher
2 Implementation of DES (S-DES) symmetric-key block
cipher
3 Implementation of RSA algorithm as a public key
encryption technique
4 Implementation of Diffie-Hellman Key Exchange
Computational and AES
5 Implementation of Hashing functions: SHA-1 algorithm
and Cryptographic Hash Function
6 Implementation of Digital signature
7 Implementation of Foot printing
8 Implementation of IP security methods
9 Working and advantages of Steganography tools
10 DoS attack and understanding tools
Internal External
EXPERIMENT-1
AIM: Write the code to implement Block Cipher and Play Fair Cipher with an example
output.
PROGRAM:
1. //Block cipher
#include <iostream>
#include <string>
std::string encryptBlockCipher(const std::string& plaintext, int shift) {
std::string ciphertext = plaintext;
for (char& ch : ciphertext) {
if (isalpha(ch)) {
char base = isupper(ch) ? 'A' : 'a';
ch = (ch - base + shift) % 26 + base;
}
}
return ciphertext;
}
int main() {
std::string plaintext;
int shift;
std::cout << "Enter plaintext: ";
std::getline(std::cin, plaintext);
std::cout << "Enter shift value: ";
std::cin >> shift;
std::string ciphertext = encryptBlockCipher(plaintext, shift);
std::cout << "Ciphertext: " << ciphertext << std::endl;
return 0;
}
OUTPUT:
2. //Play fair cipher
#include <iostream>
#include <vector>
#include <algorithm>
// Function to generate the key table
std::vector<std::vector<char>> generateKeyTable(const std::string& key) {
std::vector<std::vector<char>> table(5, std::vector<char>(5, 0));
std::string keyWithoutDuplicates = key;
// Remove duplicate characters from the key
keyWithoutDuplicates.erase(std::remove_if(keyWithoutDuplicates.begin(),
keyWithoutDuplicates.end(),
[](char c) { return !isalpha(c); }), keyWithoutDuplicates.end());
// Fill in the key table
std::string alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"; // Note: 'J' is omitted
std::string keyAndAlphabet = keyWithoutDuplicates + alphabet;
auto it = keyAndAlphabet.begin();
for (int i = 0; i < 5; ++i) {
for (int j = 0; j < 5; ++j) {
while (std::count(keyAndAlphabet.begin(), it, *it) > 1) {
++it;
}
table[i][j] = *it++;
}
}
return table;
}
// Function to find the position of a character in the key table
void findPosition(const std::vector<std::vector<char>>& table, char ch, int& row,
int& col) {
if (ch == 'J') ch = 'I'; // 'J' and 'I' are usually treated as the same letter in Playfair
cipher
for (int i = 0; i < 5; ++i) {
for (int j = 0; j < 5; ++j) {
if (table[i][j] == ch) {
row = i;
col = j;
return;
}
}
}
}
// Function to encrypt using Playfair cipher
std::string encryptPlayfair(const std::string& plaintext, const
std::vector<std::vector<char>>& table) {
std::string ciphertext;
size_t len = plaintext.length();
char first, second;
int row1, col1, row2, col2;
for (size_t i = 0; i < len; i += 2) {
first = plaintext[i];
second = (i + 1 < len) ? plaintext[i + 1] : 'X';
findPosition(table, first, row1, col1);
findPosition(table, second, row2, col2);
if (row1 == row2) {
ciphertext += table[row1][(col1 + 1) % 5];
ciphertext += table[row2][(col2 + 1) % 5];
} else if (col1 == col2) {
ciphertext += table[(row1 + 1) % 5][col1];
ciphertext += table[(row2 + 1) % 5][col2];
} else {
ciphertext += table[row1][col2];
ciphertext += table[row2][col1];
}
}
return ciphertext;
}
int main() {
std::string key, plaintext;
std::cout << "Enter the key for Playfair cipher: ";
std::cin >> key;
std::cout << "Enter plaintext: ";
std::cin >> plaintext;
// Generate the key table
std::vector<std::vector<char>> keyTable = generateKeyTable(key);
// Encrypt the plaintext
std::string ciphertext = encryptPlayfair(plaintext, keyTable);
std::cout << "Ciphertext: " << ciphertext << std::endl;
return 0;
}
OUTPUT:
EXPERIMENT-2
AIM: Implement Simplified DES (S-DES) as a symmetric-key block cipher. The S-DES
encryption algorithm takes an 8-bit block of plaintext and a 10-bit key as an input and
produces an 8-bit block of cipher text as its output.
PROGRAM:
def permute(input_block, permutation):
return [input_block[i - 1] for i in permutation]
def generate_keys(key):
p10_key = permute(key, [3, 5, 2, 7, 4, 10, 1, 9, 8, 6])
left_half = p10_key[:5]
right_half = p10_key[5:]
shifted_left_half = left_half[1:] + [left_half[0]]
shifted_right_half = right_half[1:] + [right_half[0]]
key1 = permute(shifted_left_half + shifted_right_half, [6, 3, 7, 4, 8, 5, 10, 9])
double_shifted_left_half = shifted_left_half[1:] + [shifted_left_half[0]]
double_shifted_right_half = shifted_right_half[1:] + [shifted_right_half[0]]
key2 = permute(double_shifted_left_half + double_shifted_right_half, [6, 3, 7, 4, 8, 5, 10, 9])
return key1, key2
def f_function(input_block, key):
expanded_input = permute(input_block, [4, 1, 2, 3, 2, 3, 4, 1])
xor_result = [bit1 ^ bit2 for bit1, bit2 in zip(expanded_input, key)]
left_half = xor_result[:4]
right_half = xor_result[4:]
s_box_output = s_box(left_half, S0) + s_box(right_half, S1)
return permute(s_box_output, [2, 4, 3, 1])
def s_box(input_bits, s_box_table):
row = 2 * input_bits[0] + input_bits[3]
col = 2 * input_bits[1] + input_bits[2]
return list(map(int, list(format(s_box_table[row][col], '02b'))))
def initial_permutation(plaintext):
return permute(plaintext, [2, 6, 3, 1, 4, 8, 5, 7])
def inverse_permutation(ciphertext):
return permute(ciphertext, [4, 1, 3, 5, 7, 2, 8, 6])
def encrypt_sdes(plaintext, key):
initial_permuted_text = initial_permutation(plaintext)
left_half = initial_permuted_text[:4]
right_half = initial_permuted_text[4:]
key1, key2 = generate_keys(key)
new_left_half1 = right_half
f_result1 = f_function(right_half, key1)
new_right_half1 = [bit1 ^ bit2 for bit1, bit2 in zip(left_half, f_result1)]
new_left_half2 = new_right_half1
f_result2 = f_function(new_right_half1, key2)
new_right_half2 = [bit1 ^ bit2 for bit1, bit2 in zip(right_half, f_result2)]
final_ciphertext = inverse_permutation(new_left_half2 + new_right_half2)
return final_ciphertext
# Example usage:
plaintext = [1, 1, 0, 1, 1, 0, 1, 0] # 8-bit plaintext
key = [1, 0, 0, 1, 0, 0, 1, 0, 1, 1] # 10-bit key
S0 = [
[1, 0, 3, 2],
[3, 2, 1, 0],
[0, 2, 1, 3],
[3, 1, 3, 2]
S1 = [
[0, 1, 2, 3],
[2, 0, 1, 3],
[3, 0, 1, 0],
[2, 1, 0, 3]
ciphertext = encrypt_sdes(plaintext, key)
print("Ciphertext:", ciphertext)
OUTPUT:
