Untitled
unknown
plain_text
a month ago
17 kB
5
Indexable
Mahatma Education Society’s
Pillai College of Arts, Commerce & Science
(Autonomous)
Affiliated to University of Mumbai
NAAC Accredited 'A' grade (3 cycles) Best College Award by University of Mumbai
ISO 9001:2015 Certified
CERTIFICATE
This is to certify that Mr. _ Amit Pandey____ of M.Sc. D.A. Part-I Semester II has completed the practical work in the Subject of Network Security & Cryptography during the academic year 2024-25 under the guidance of Prof. __Simran Shinde__being the partial requirement for the fulfillment of the curriculum of Degree of Master of Science in Data Analytics, University of Mumbai.
Place:
Date:
Name & Signature of faculty Name & Signature of external
INDEX
Practical No.
Aim
Date
Sign
1.
Write programs to implement the following Substitution Cipher Techniques: -
1. Caesar Cipher - Encryption and Decryption
29|11|2024
2.
Write programs to implement the following Substitution Cipher Techniques:
1. Playfair Cipher
2. Vernam Cipher
29|11|2024
3.
Write programs to implement the following Transposition Cipher Techniques:
1. Rail Fence Cipher
2. Simple Columnar Technique
23|12|2024
4.
Write a program to encrypt and decrypt strings using DES Algorithm.
31|01|2025
5.
Write a program to encrypt and decrypt strings using AES Algorithm.
31|01|2025
6.
Write a program to implement the Diffie-Hellman Key Agreement algorithm to generate symmetric keys.
06|02|2025
7.
Write a program to implement the MD5 algorithm to compute the message digest.
03|03|2025
8.
Write a program to calculate HMAC-SHA1
Signature.
03|03|2025
9.
Write a python program to illustrate Elgamal encryption.
03|03|2025
PRACTICAL 1
Aim: Write a program to implement the following Substitution Cipher Techniques.
1. Caesar Cipher(Encryption and Decryption)
Code :
def caesar_cipher(text, shift):
result = ''
for char in text:
if char.isalpha():
start = ord('a') if char.islower() else ord('A')
shifted_char = chr((ord(char) - start + shift) % 26 + start)
elif char.isdigit():
shifted_char = str((int(char) + shift) % 10)
else:
shifted_char = char
result += shifted_char
return result
# Example usage:
text = input("Enter the text to be encrypted: ")
key = 4
encrypted_text = caesar_cipher(text, key)
print("Encrypted:", encrypted_text)
decrypted_text = caesar_cipher(encrypted_text, -key)
print("Decrypted:", decrypted_text)
Output :
PRACTICAL 2
Aim: Write a program to implement the following Substitution Cipher Techniques.
1. Playfair Cipher
Code :
import string
def prepare_text(text, fill_char='X'):
text = ''.join(c for c in text.upper().replace('J', 'I') if c in string.ascii_uppercase)
prepared_text = ""
for i in range(len(text)):
prepared_text += text[i]
if i + 1 < len(text) and text[i] == text[i + 1]:
prepared_text += fill_char
if len(prepared_text) % 2 != 0:
prepared_text += fill_char
return prepared_text
def create_key_matrix(key):
key = ''.join(c for c in key.upper().replace('J', 'I') if c in string.ascii_uppercase)
key = ''.join(sorted(set(key), key=key.index)) # Remove duplicates while preserving order
alphabet = string.ascii_uppercase.replace('J', '')
return [list(key + ''.join(c for c in alphabet if c not in key))[i:i + 5] for i in range(0, 25, 5)]
def find_position(matrix, char):
for r, row in enumerate(matrix):
if char in row:
return r, row.index(char)
def playfair(text, matrix, decrypt=False):
text = prepare_text(text)
shift = -1 if decrypt else 1
result = ""
for i in range(0, len(text), 2):
r1, c1 = find_position(matrix, text[i])
r2, c2 = find_position(matrix, text[i + 1])
if r1 == r2:
result += matrix[r1][(c1 + shift) % 5] + matrix[r2][(c2 + shift) % 5]
elif c1 == c2:
result += matrix[(r1 + shift) % 5][c1] + matrix[(r2 + shift) % 5][c2]
else:
result += matrix[r1][c2] + matrix[r2][c1]
return result
# Main program
print("=== Playfair Cipher ===")
# Input key
key = input("Enter the key (text used for generating cipher matrix): ").strip()
# Generate key matrix
try:
cipher_matrix = create_key_matrix(key)
except ValueError:
print("Error: Invalid key provided.")
exit()
print("\nKey Matrix:")
for row in cipher_matrix:
print(row)
# Input plaintext
plaintext = input("\nEnter the plaintext to encrypt: ").strip()
# Encrypt
encrypted = playfair(plaintext, cipher_matrix)
print("\nEncrypted Text:", encrypted)
# Decrypt
decrypted = playfair(encrypted, cipher_matrix, decrypt=True)
print("\nDecrypted Text:", decrypted)
Output :
2. Vernam Cipher
Code :
import string
def vernam_cipher(text, key):
"""
Encrypt or decrypt text using Vernam cipher with a key.
"""
if len(text) != len(key):
raise ValueError("Key must be the same length as the plaintext!")
# Perform XOR operation
result = ''.join(chr(ord(t) ^ ord(k)) for t, k in zip(text, key))
return result
def text_to_hex(text):
"""
Convert text to a readable hexadecimal representation.
"""
return ' '.join(f"{ord(c):02X}" for c in text)
# Main program
print("=== Vernam Cipher ===")
# Input plaintext
plaintext = input("Enter the plaintext: ").strip()
plaintext = ''.join(c for c in plaintext if c in string.printable) # Sanitize input
# Input key
key = input("Enter the key (must be the same length as the plaintext): ").strip()
key = ''.join(c for c in key if c in string.printable) # Sanitize input
if len(plaintext) != len(key):
print("Error: Key length must match plaintext length!")
else:
# Encrypt
encrypted_text = vernam_cipher(plaintext, key)
encrypted_hex = text_to_hex(encrypted_text)
print("\nEncrypted Text (non-readable ASCII):", encrypted_text)
print("Encrypted Text (hexadecimal):", encrypted_hex)
# Decrypt (using the same function as XOR is reversible)
decrypted_text = vernam_cipher(encrypted_text, key)
print("\nDecrypted Text:", decrypted_text)
Output :
PRACTICAL 3
Aim: Write a program to implement the following Transposition Cipher Techniques.
1. Rail Fence Cipher
Code :
def rail_fence_encrypt(text, key):
fence = [['' for _ in range(len(text))] for _ in range(key)]
direction = 1
row, col = 0, 0
for char in text:
fence[row][col] = char
col += 1
row += direction
if row == key - 1 or row == 0:
direction *= -1
encrypted_text = ''
for i in range(key):
for j in range(len(text)):
if fence[i][j] != '':
encrypted_text += fence[i][j]
return encrypted_text
def rail_fence_decrypt(text, key):
fence = [['' for _ in range(len(text))] for _ in range(key)]
direction = 1
row, col = 0, 0
for i in range(len(text)):
fence[row][col] = '*'
col += 1
row += direction
if row == key - 1 or row == 0:
direction *= -1
index = 0
for i in range(key):
for j in range(len(text)):
if fence[i][j] == '*':
fence[i][j] = text[index]
index += 1
decrypted_text = ''
direction = 1
row, col = 0, 0
for i in range(len(text)):
decrypted_text += fence[row][col]
col += 1
row += direction
if row == key - 1 or row == 0:
direction *= -1
return decrypted_text
# Example usage:
text = input("Enter the text to be encrypted: ")
key = 3 # Example key, you can change it
encrypted_text = rail_fence_encrypt(text, key)
print("Encrypted:", encrypted_text)
decrypted_text = rail_fence_decrypt(encrypted_text, key)
print("Decrypted:", decrypted_text)
Output :
2. Row Column Transposition
Code :
import math
def row_column_transposition_encrypt(text, key):
text_length = len(text)
rows = int(math.ceil(text_length / key)) # Number of rows needed
matrix = [['' for _ in range(key)] for _ in range(rows)]
# Fill the matrix row by row
index = 0
for i in range(rows):
for j in range(key):
if index < text_length:
matrix[i][j] = text[index]
index += 1
# Read the matrix column by column to create the ciphertext
result = ''
for j in range(key):
for i in range(rows):
if matrix[i][j] != '': # Only add non-empty characters
result += matrix[i][j]
return result
def row_column_transposition_decrypt(ciphertext, key):
text_length = len(ciphertext)
rows = int(math.ceil(text_length / key)) # Number of rows needed
matrix = [['' for _ in range(key)] for _ in range(rows)]
# Fill the matrix column by column
index = 0
for j in range(key):
for i in range(rows):
if index < text_length:
matrix[i][j] = ciphertext[index]
index += 1
# Read the matrix row by row to reconstruct the plaintext
result = ''
for i in range(rows):
for j in range(key):
result += matrix[i][j]
return result.strip() # Remove trailing spaces if any
# Example usage:
if __name__ == "__main__":
text = input("Enter the text: ")
key = int(input("Enter the key (number of columns): "))
encrypted_text = row_column_transposition_encrypt(text, key)
print("Encrypted Text:", encrypted_text)
decrypted_text = row_column_transposition_decrypt(encrypted_text, key)
print("Decrypted Text:", decrypted_text)
Output :
PRACTICAL 4
Aim: Write a program to encrypt and decrypt strings using DES Algorithm.
Code :
pip install pycryptodome
#DES
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
import base64
# Generate a random 8-byte key for DES
def generate_key():
return get_random_bytes(8) # DES key size is 8 bytes (64 bits)
# Encrypt function using DES
def encrypt_data(key, data):
cipher = DES.new(key, DES.MODE_ECB)
# Pad data to make sure it's a multiple of DES block size (8 bytes)
padded_data = pad(data.encode(), DES.block_size)
encrypted_data = cipher.encrypt(padded_data)
# Return the encrypted data as a base64 encoded string
return base64.b64encode(encrypted_data).decode('utf-8')
# Decrypt function using DES
def decrypt_data(key, encrypted_data):
cipher = DES.new(key, DES.MODE_ECB)
# Decode the base64 encoded encrypted data
encrypted_data_bytes = base64.b64decode(encrypted_data)
# Decrypt the data and unpad it
decrypted_data = unpad(cipher.decrypt(encrypted_data_bytes), DES.block_size)
return decrypted_data.decode('utf-8')
if __name__ == "__main__":
# Generate a DES key
key = generate_key()
print(f"Generated DES Key: {base64.b64encode(key).decode('utf-8')}")
# Data to be encrypted
data = "HELLO WORLD"
# Encrypt the data
encrypted_data = encrypt_data(key, data)
print(f"Encrypted Data: {encrypted_data}")
# Decrypt the data
decrypted_data = decrypt_data(key, encrypted_data)
print(f"Decrypted Data: {decrypted_data}")
Output:
PRACTICAL 5
Aim: Write a program to encrypt and decrypt strings using AES Algorithm.
Code :
pip install pycryptodome
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
import base64
# Generate a random 16-byte key for AES (AES-128)
def generate_key():
return get_random_bytes(16) # 128-bit AES key
# Encrypt function using AES
def encrypt_data(key, data):
cipher = AES.new(key, AES.MODE_ECB)
# Pad data to make sure it's a multiple of AES block size (16 bytes)
padded_data = pad(data.encode(), AES.block_size)
encrypted_data = cipher.encrypt(padded_data)
# Return the encrypted data as a base64 encoded string for easy storage/transfer
return base64.b64encode(encrypted_data).decode('utf-8')
# Decrypt function using AES
def decrypt_data(key, encrypted_data):
cipher = AES.new(key, AES.MODE_ECB)
# Decode the base64 encoded encrypted data
encrypted_data_bytes = base64.b64decode(encrypted_data)
# Decrypt the data and unpad it
decrypted_data = unpad(cipher.decrypt(encrypted_data_bytes), AES.block_size)
return decrypted_data.decode('utf-8')
if __name__ == "__main__":
# Generate an AES key
key = generate_key()
print(f"Generated AES Key: {base64.b64encode(key).decode('utf-8')}")
# Data to be encrypted
data = "HELLO WORLD"
# Encrypt the data
encrypted_data = encrypt_data(key, data)
print(f"Encrypted Data: {encrypted_data}")
# Decrypt the data
decrypted_data = decrypt_data(key, encrypted_data)
print(f"Decrypted Data: {decrypted_data}")
Output:
PRACTICAL 6
Aim: Write a program to implement the Diffie-Hellman Key Agreement algorithm to generate symmetric keys.
Code :
import random
import hashlib
# Function to compute modular exponentiation (g^a mod p)
def mod_exp(base, exp, mod):
return pow(base, exp, mod)
# Generate Diffie-Hellman shared secret
def diffie_hellman(p, g):
# Step 1: Alice's private key (randomly chosen)
a = random.randint(1, p - 1)
# Alice computes public key A = g^a mod p
A = mod_exp(g, a, p)
# Step 2: Bob's private key (randomly chosen)
b = random.randint(1, p - 1)
# Bob computes public key B = g^b mod p
B = mod_exp(g, b, p)
print(f"Alice's private key: {a}")
print(f"Alice's public key: {A}")
print(f"Bob's private key: {b}")
print(f"Bob's public key: {B}")
# Step 3: Exchange public keys
# Alice computes shared secret K = B^a mod p
shared_secret_alice = mod_exp(B, a, p)
# Bob computes shared secret K = A^b mod p
shared_secret_bob = mod_exp(A, b, p)
# Both should compute the same shared secret
print(f"Alice's computed shared secret: {shared_secret_alice}")
print(f"Bob's computed shared secret: {shared_secret_bob}")
# Step 4: Generate a symmetric key from the shared secret (using a hash function)
symmetric_key = hashlib.sha256(str(shared_secret_alice).encode()).hexdigest()
print(f"Generated symmetric key: {symmetric_key}")
return symmetric_key
# Example usage:
if __name__ == "__main__":
# Public parameters (p is a large prime, g is a primitive root mod p)
p = 23 # A small prime for simplicity; in practice, use a large prime
g = 5 # A primitive root modulo p
symmetric_key = diffie_hellman(p, g)
Output :
PRACTICAL 7
Aim:Write a program to implement the MD5 algorithm to compute the message digest.
Code:
import hashlib
def md5(msg: str) -> str:
return hashlib.md5(msg.encode()).hexdigest()
# Test the MD5 function
message = "Hello World!"
print("MD5 Digest:", md5(message))
Output :
PRACTICAL 8
Aim:Write a program to calculate HMAC-SHA1 Signature.
Code:
import hmac
import hashlib
def calculate_hmac_sha1(key: str, message: str) -> str:
# Create a new HMAC object with the given key and message, using SHA-1 as the hashing algorithm
hmac_sha1 = hmac.new(key.encode(), message.encode(), hashlib.sha1)
# Return the HMAC-SHA1 signature as a hexadecimal string
return hmac_sha1.hexdigest()
# Example usage
key = "secret_key"
message = "Hello, HMAC-SHA1!"
hmac_signature = calculate_hmac_sha1(key, message)
print("HMAC-SHA1 Signature:", hmac_signature)
Output :
PRACTICAL 9
Aim: Write a python program to illustrate Elgamal encryption.
Code:
import random
from sympy import mod_inverse
def generate_keys(prime, base):
private_key = random.randint(2, prime - 2)
public_key = pow(base, private_key, prime)
return private_key, public_key
def encrypt(prime, base, public_key, message):
k = random.randint(2, prime - 2) # Random ephemeral key
c1 = pow(base, k, prime)
c2 = (message * pow(public_key, k, prime)) % prime
return c1, c2
def decrypt(prime, private_key, c1, c2):
s = pow(c1, private_key, prime)
s_inv = mod_inverse(s, prime)
message = (c2 * s_inv) % prime
return message
def elgamal_demo():
prime = 23 # Small prime number
base = 5 # Primitive root modulo prime
# Key generation
private_key, public_key = generate_keys(prime, base)
print(f"Prime (Public): {prime}")
print(f"Base (Public): {base}")
print(f"Private Key (Secret): {private_key}")
print(f"Public Key: {public_key}")
message = 8 # Message to be encrypted (must be smaller than prime)
print(f"Original Message: {message}")
# Encryption
c1, c2 = encrypt(prime, base, public_key, message)
print(f"Encrypted Message: (c1: {c1}, c2: {c2})")
# Decryption
decrypted_message = decrypt(prime, private_key, c1, c2)
print(f"Decrypted Message: {decrypted_message}")
if __name__ == "__main__":
elgamal_demo()
Output:
Editor is loading...
Leave a Comment