Name - Shaikh Juveria Shafi Ahmed Roll No.
- SY MSc CS 05
Practical No. - 01
Aim - Implement a Basic Encryption and Decryption Process for Plaintext
Data. Use Cryptographic Libraries (e.g., OpenSSL, Python
Cryptography Library or a Similar Encryption Toolkit) to Encrypt and
Decrypt a Given Plaintext Message.
__________________________________________________________________
Theory:
Encryption is the process of converting plaintext data into a coded format, known as ciphertext,
to prevent unauthorized access. This transformation uses an algorithm and a key, ensuring that
only those with the correct key can decrypt and access the original data. Decryption is the
reverse process, converting ciphertext back into its original plaintext format using a key.
Encryption and decryption are fundamental to data security, ensuring confidentiality and
protecting information during transmission or storage. Symmetric encryption uses the same key
for both processes, while asymmetric encryption uses a pair of keys—a public key for encryption
and a private key for decryption.
Source Code: [Link]
from [Link] import Fernet
# Generate a key for encryption and decryption
def generate_key():
return Fernet.generate_key()
# Encrypt a message
def encrypt_message(message, key):
fernet = Fernet(key)
encrypted_message = [Link]([Link]())
return encrypted_message
# Decrypt a message
def decrypt_message(encrypted_message, key):
fernet = Fernet(key)
decrypted_message = [Link](encrypted_message).decode()
return decrypted_message
# Example usage:
key = generate_key()
print("Encryption Key: ", key) # Print the key as bytes
message = input("Enter the plaintext: ")
encrypted_message = encrypt_message(message, key)
Subject - Network Security and Cryptography 1
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 01
Aim - Implement a Basic Encryption and Decryption Process for Plaintext
Data. Use Cryptographic Libraries (e.g., OpenSSL, Python
Cryptography Library or a Similar Encryption Toolkit) to Encrypt and
Decrypt a Given Plaintext Message.
__________________________________________________________________
print("Encrypted: ", encrypted_message)
decrypted_message = decrypt_message(encrypted_message, key)
print("Decrypted: ", decrypted_message)
Output: [Link]
Subject - Network Security and Cryptography 2
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 02
Aim - Develop Encryption and Decryption Routines for DES Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
Theory:
The Data Encryption Standard (DES) is a symmetric-key block cipher that was widely used for
data encryption. Developed in the 1970s by IBM and adopted by the U.S. National Institute of
Standards and Technology (NIST) in 1977, DES encrypts data in 64-bit blocks using a 56-bit
key. DES operates through a series of permutations and substitutions, creating complex
encryption transformations. Although it was considered secure for many years, advancements in
computing power have made DES vulnerable to brute-force attacks. As a result, DES has been
largely replaced by more secure algorithms like AES (Advanced Encryption Standard) in modern
applications.
Source Code: [Link]
from [Link] import DES
from [Link] import pad, unpad
import base64
# Function to encrypt plaintext using DES
def des_encrypt(plaintext, key):
# Convert the key and plaintext to bytes
key = [Link]('utf-8')
plaintext = [Link]('utf-8')
# Create a new DES cipher in ECB mode
cipher = [Link](key, DES.MODE_ECB)
# Pad the plaintext to be a multiple of 8 bytes
padded_text = pad(plaintext, DES.block_size)
# Encrypt the padded plaintext
encrypted_text = [Link](padded_text)
# Convert encrypted bytes to base64 to get a printable string
encrypted_text_base64 = base64.b64encode(encrypted_text).decode('utf-8')
return encrypted_text_base64
# Function to decrypt ciphertext using DES
Subject - Network Security and Cryptography 3
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 02
Aim - Develop Encryption and Decryption Routines for DES Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
def des_decrypt(ciphertext_base64, key):
# Convert the key and ciphertext to bytes
key = [Link]('utf-8')
ciphertext = base64.b64decode(ciphertext_base64)
# Create a new DES cipher in ECB mode
cipher = [Link](key, DES.MODE_ECB)
# Decrypt the ciphertext
decrypted_padded_text = [Link](ciphertext)
# Unpad the decrypted plaintext
decrypted_text = unpad(decrypted_padded_text, DES.block_size).decode('utf-8')
return decrypted_text
# Main program with user input and menu options
def main():
while True:
print("\nChoose an option:")
print("1. Encrypt")
print("2. Decrypt")
print("3. Exit")
choice = input("Enter your choice (1/2/3): ")
if choice == '1':
plaintext = input("Enter the plaintext to encrypt: ")
key = input("Enter an 8-character key: ")
if len(key) != 8:
print("Key must be exactly 8 characters long.")
continue
ciphertext = des_encrypt(plaintext, key)
print(f"Encrypted Text: {ciphertext}")
elif choice == '2':
ciphertext = input("Enter the base64-encoded ciphertext to decrypt: ")
key = input("Enter the 8-character key used for encryption: ")
if len(key) != 8:
Subject - Network Security and Cryptography 4
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 02
Aim - Develop Encryption and Decryption Routines for DES Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
print("Key must be exactly 8 characters long.")
continue
try:
decrypted_text = des_decrypt(ciphertext, key)
print(f"Decrypted Text: {decrypted_text}")
except (ValueError, KeyError):
print("Decryption failed. Check your key and ciphertext.")
elif choice == '3':
print("Exiting the program.")
break
else:
print("Invalid choice. Please try again.")
# Run the main function
if __name__ == "__main__":
main()
Output: [Link]
Subject - Network Security and Cryptography 5
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 03
Aim - Develop the Elgamal Encryption System, Including Key Generation,
Encryption and Decryption Processes. Tools/Technologies:
Cryptographic Libraries, Python or Specialized Encryption Software.
__________________________________________________________________
Theory:
The ElGamal encryption system is a public-key cryptosystem based on the Diffie-Hellman key
exchange. Developed by Taher ElGamal in 1984, it uses asymmetric cryptography to encrypt and
decrypt messages. The system involves selecting a large prime number ‘p’ and a generator ‘g’ of
the multiplicative group modulo ‘p’. Each user has a private key ‘x’ and a public key ‘y’, where
y = gx mod p. Encryption involves choosing a random integer ‘k’ to generate a pair of ciphertext
values. Decryption requires the private key to recover the original message. ElGamal is known
for its security based on the hardness of the discrete logarithm problem.
Source Code: [Link]
import random
def generate_keys():
# Step 1: Enter a large prime number p
p = int(input("Enter a large prime number p: "))
# Step 2: Choose a generator g of the multiplicative group Z_p^*
g = int(input("Enter a generator g: "))
# Step 3: Select a private key x
x = [Link](1, p-2) # 1 <= x < p-1
# Step 4: Compute the public key y
y = pow(g, x, p)
# Public key (p, g, y) and private key (x)
public_key = (p, g, y)
private_key = x
return public_key, private_key
def encrypt(public_key, message):
p, g, y = public_key
# Step 1: Convert the message to an integer (for simplicity, assuming message is an integer)
m = message
Subject - Network Security and Cryptography 6
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 03
Aim - Develop the Elgamal Encryption System, Including Key Generation,
Encryption and Decryption Processes. Tools/Technologies:
Cryptographic Libraries, Python or Specialized Encryption Software.
__________________________________________________________________
# Step 2: Choose a random integer k
k = [Link](1, p-2) # 1 <= k < p-1
# Step 3: Compute ciphertext components
c1 = pow(g, k, p)
c2 = (m * pow(y, k, p)) % p
# Return the ciphertext as a tuple (c1, c2)
return (c1, c2)
def decrypt(ciphertext, public_key, private_key):
p, g, y = public_key
x = private_key
c1, c2 = ciphertext
# Step 1: Compute the plaintext message
s = pow(c1, x, p)
plaintext = (c2 * pow(s, p-2, p)) % p
# Return the plaintext (assuming it's an integer for simplicity)
return plaintext
# Example usage
public_key, private_key = generate_keys()
print("Public Key:", public_key)
print("Private Key:", private_key)
message = 9
print("Original Message:", message)
ciphertext = encrypt(public_key, message)
print("Ciphertext:", ciphertext)
decrypted_message = decrypt(ciphertext, public_key, private_key)
print("Decrypted Message:", decrypted_message)
Subject - Network Security and Cryptography 7
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 03
Aim - Develop the Elgamal Encryption System, Including Key Generation,
Encryption and Decryption Processes. Tools/Technologies:
Cryptographic Libraries, Python or Specialized Encryption Software.
__________________________________________________________________
Output: [Link]
Subject - Network Security and Cryptography 8
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 04
Aim - Implement the Playfair Cipher Algorithm and Develop Encryption and
Decryption Routines, Including the 5x5 Matrix and Matrix Indexes.
Tools/Technologies: Programming Languages, such as Python or Java
for algorithm Implementation.
__________________________________________________________________
Theory:
The Playfair cipher is a digraph substitution cipher devised by Charles Wheatstone in 1854 and
popularized by Sir Frank Playfair. It encrypts pairs of letters rather than single letters. The
algorithm uses a 5x5 matrix of letters, constructed from a keyword, with the remaining letters of
the alphabet (excluding duplicates and usually combining 'I' and 'J' into one) filling the rest. To
encrypt, each pair of plaintext letters is located in the matrix and substituted based on their
positions: if they’re in the same row or column, they’re replaced by letters in the same row or
column but shifted. If not, they form a rectangle, and the opposite corners are swapped. This
method enhances security compared to simple substitution ciphers.
Source Code: [Link]
import numpy as np
# Function to prepare the Playfair matrix based on a keyword
def create_playfair_matrix(keyword):
keyword = [Link]().replace('J', 'I')
seen = set()
matrix = []
# Add keyword to matrix and remove duplicates
for char in keyword:
if char not in seen and [Link]():
[Link](char)
[Link](char)
# Add remaining letters of the alphabet
for char in 'ABCDEFGHIKLMNOPQRSTUVWXYZ': # 'J' is omitted (replaced with 'I')
if char not in seen:
[Link](char)
# Reshape the list into a 5x5 matrix
matrix = [Link](matrix).reshape(5, 5)
return matrix
Subject - Network Security and Cryptography 9
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 04
Aim - Implement the Playfair Cipher Algorithm and Develop Encryption and
Decryption Routines, Including the 5x5 Matrix and Matrix Indexes.
Tools/Technologies: Programming Languages, such as Python or Java
for algorithm Implementation.
__________________________________________________________________
# Function to find the position of a letter in the matrix
def find_position(matrix, char):
for i, row in enumerate(matrix):
for j, matrix_char in enumerate(row):
if matrix_char == char:
return i, j
return None
# Function to format the plaintext
def format_text(plaintext):
plaintext = [Link]().replace('J', 'I')
formatted_text = ""
# Remove non-alphabetic characters
plaintext = ''.join([char for char in plaintext if [Link]()])
# Add 'X' between repeating characters and at the end if odd length
i=0
while i < len(plaintext):
formatted_text += plaintext[i]
if i + 1 < len(plaintext) and plaintext[i] == plaintext[i + 1]:
formatted_text += 'X'
elif i + 1 < len(plaintext):
formatted_text += plaintext[i + 1]
i += 1
i += 1
if len(formatted_text) % 2 != 0:
formatted_text += 'X'
return formatted_text
# Function to encrypt the plaintext using Playfair cipher
def playfair_encrypt(plaintext, matrix):
plaintext = format_text(plaintext)
ciphertext = ""
Subject - Network Security and Cryptography 10
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 04
Aim - Implement the Playfair Cipher Algorithm and Develop Encryption and
Decryption Routines, Including the 5x5 Matrix and Matrix Indexes.
Tools/Technologies: Programming Languages, such as Python or Java
for algorithm Implementation.
__________________________________________________________________
for i in range(0, len(plaintext), 2):
char1, char2 = plaintext[i], plaintext[i + 1]
row1, col1 = find_position(matrix, char1)
row2, col2 = find_position(matrix, char2)
if row1 == row2:
# Same row, shift right
ciphertext += matrix[row1][(col1 + 1) % 5] + matrix[row2][(col2 + 1) % 5]
elif col1 == col2:
# Same column, shift down
ciphertext += matrix[(row1 + 1) % 5][col1] + matrix[(row2 + 1) % 5][col2]
else:
# Rectangle swap
ciphertext += matrix[row1][col2] + matrix[row2][col1]
return ciphertext
# Function to decrypt the ciphertext using Playfair cipher
def playfair_decrypt(ciphertext, matrix):
plaintext = ""
for i in range(0, len(ciphertext), 2):
char1, char2 = ciphertext[i], ciphertext[i + 1]
row1, col1 = find_position(matrix, char1)
row2, col2 = find_position(matrix, char2)
if row1 == row2:
# Same row, shift left
plaintext += matrix[row1][(col1 - 1) % 5] + matrix[row2][(col2 - 1) % 5]
elif col1 == col2:
# Same column, shift up
plaintext += matrix[(row1 - 1) % 5][col1] + matrix[(row2 - 1) % 5][col2]
else:
# Rectangle swap
plaintext += matrix[row1][col2] + matrix[row2][col1]
return plaintext
Subject - Network Security and Cryptography 11
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 04
Aim - Implement the Playfair Cipher Algorithm and Develop Encryption and
Decryption Routines, Including the 5x5 Matrix and Matrix Indexes.
Tools/Technologies: Programming Languages, such as Python or Java
for algorithm Implementation.
__________________________________________________________________
# Main program with user input and menu options
def main():
keyword = input("Enter the keyword for the Playfair Cipher: ")
matrix = create_playfair_matrix(keyword)
while True:
print("\nChoose an option:")
print("1. Encrypt")
print("2. Decrypt")
print("3. Exit")
choice = input("Enter your choice (1/2/3): ")
if choice == '1':
plaintext = input("Enter the plaintext to encrypt: ")
ciphertext = playfair_encrypt(plaintext, matrix)
print(f"Ciphertext: {ciphertext}")
elif choice == '2':
ciphertext = input("Enter the ciphertext to decrypt: ")
decrypted_text = playfair_decrypt(ciphertext, matrix)
print(f"Decrypted Text: {decrypted_text}")
elif choice == '3':
print("Exiting the program.")
break
else:
print("Invalid choice. Please try again.")
# Run the main function
if __name__ == "__main__":
main()
Subject - Network Security and Cryptography 12
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 04
Aim - Implement the Playfair Cipher Algorithm and Develop Encryption and
Decryption Routines, Including the 5x5 Matrix and Matrix Indexes.
Tools/Technologies: Programming Languages, such as Python or Java
for algorithm Implementation.
__________________________________________________________________
Output: [Link]
Subject - Network Security and Cryptography 13
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 05
Aim - Implement Cryptographic Algorithm Diffie-Hellman Key Exchange.
Tools/Technologies: Cryptographic Libraries, Programming Languages
and Hashing Utilities.
__________________________________________________________________
Theory:
The Diffie-Hellman key exchange is a cryptographic protocol allowing two parties to securely
share a secret key over an insecure communication channel. Introduced by Whitfield Diffie and
Martin Hellman in 1976, it leverages modular arithmetic and the difficulty of solving discrete
logarithms. Both parties agree on a large prime number ‘p’ and a base ‘g’. Each party generates a
private key and computes a public key based on ‘g’ and their private key. They exchange public
keys and each computes the shared secret using their private key and the other party’s public key.
The shared secret is identical for both parties and can be used for symmetric encryption.
Source Code: [Link]
import random
def generate_private_key(p):
"""Generate a private key."""
return [Link](2, p-2)
def generate_public_key(p, g, private_key):
"""Generate a public key."""
return pow(g, private_key, p)
def compute_shared_secret(public_key, private_key, p):
"""Compute the shared secret key."""
return pow(public_key, private_key, p)
def main():
# Step 1: Select a large prime number p and a generator g
p = int(input("Enter a large prime number p: "))
g = int(input("Enter a generator g: "))
# Each party generates their private and public keys
print("\nParty A:")
private_key_a = generate_private_key(p)
public_key_a = generate_public_key(p, g, private_key_a)
print(f"Private Key A: {private_key_a}")
print(f"Public Key A: {public_key_a}")
Subject - Network Security and Cryptography 14
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 05
Aim - Implement Cryptographic Algorithm Diffie-Hellman Key Exchange.
Tools/Technologies: Cryptographic Libraries, Programming Languages
and Hashing Utilities.
__________________________________________________________________
print("\nParty B:")
private_key_b = generate_private_key(p)
public_key_b = generate_public_key(p, g, private_key_b)
print(f"Private Key B: {private_key_b}")
print(f"Public Key B: {public_key_b}")
# Each party computes the shared secret
shared_secret_a = compute_shared_secret(public_key_b, private_key_a, p)
shared_secret_b = compute_shared_secret(public_key_a, private_key_b, p)
print("\nShared Secret Computation:")
print(f"Party A's Computed Shared Secret: {shared_secret_a}")
print(f"Party B's Computed Shared Secret: {shared_secret_b}")
# Verify that both parties have the same shared secret
if shared_secret_a == shared_secret_b:
print("The shared secret is successfully established.")
else:
print("Error: The shared secrets do not match.")
# Run the main function
if __name__ == "__main__":
main()
Output: [Link]
Subject - Network Security and Cryptography 15
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 06
Aim - Develop Encryption and Decryption Routine for RSA Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
Theory:
RSA (Rivest-Shamir-Adleman) is a widely used public-key cryptographic algorithm developed
in 1977 by Ron Rivest, Adi Shamir, and Leonard Adleman. It is based on the mathematical
difficulty of factoring large composite numbers. RSA involves generating two large prime
numbers ‘p’ and ‘q’, and computing their product n = p x q. The public key consists of ‘n’ and an
exponent ‘e’, while the private key includes ‘n’ and a private exponent ‘d’, derived from ‘e’ and
the totient function of ‘n’. RSA enables secure encryption and digital signatures by utilizing
modular exponentiation.
Source Code: [Link]
import random
from sympy import isprime, mod_inverse
import base64
def generate_prime(bits=8):
"""Generate a random prime number of specified bit length."""
while True:
num = [Link](bits)
if isprime(num):
return num
def generate_keys():
"""Generate RSA public and private keys."""
p = generate_prime()
q = generate_prime()
n=p*q
phi_n = (p - 1) * (q - 1)
e = 65537 # Common choice for e
# Ensure e is coprime with phi(n) and has an inverse modulo phi(n)
d = mod_inverse(e, phi_n)
# Public key is (n, e) and private key is (n, d)
public_key = (n, e)
Subject - Network Security and Cryptography 16
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 06
Aim - Develop Encryption and Decryption Routine for RSA Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
private_key = (n, d)
return public_key, private_key
def encrypt(public_key, message):
"""Encrypt a message using RSA public key."""
n, e = public_key
# Convert the message to bytes and then to an integer
message_bytes = [Link]('utf-8')
m = int.from_bytes(message_bytes, byteorder='big')
# Encrypt the message
c = pow(m, e, n)
return c
def decrypt(private_key, ciphertext):
"""Decrypt a ciphertext using RSA private key."""
n, d = private_key
# Decrypt the ciphertext
m = pow(ciphertext, d, n)
# Convert the integer back to bytes and then decode to a string
message_bytes = m.to_bytes((m.bit_length() + 7) // 8, byteorder='big')
message = message_bytes.decode('utf-8', errors='ignore')
return message
# Example usage
public_key, private_key = generate_keys()
print("Public Key:", public_key)
print("Private Key:", private_key)
message = "Kill the PM"
print("Original Message:", message)
ciphertext = encrypt(public_key, message)
Subject - Network Security and Cryptography 17
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 06
Aim - Develop Encryption and Decryption Routine for RSA Algorithm.
Tools/Technologies: Cryptographic Libraries, Programming Languages
like Python or Java.
__________________________________________________________________
print("Ciphertext:", ciphertext)
decrypted_message = decrypt(private_key, ciphertext)
print("Decrypted Message:", decrypted_message)
Output: [Link]
Subject - Network Security and Cryptography 18
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 07
Aim - Implement Cryptographic Algorithm MD5. Tools/Technologies:
Cryptographic Libraries, Programming Languages and Hashing
Utilities.
__________________________________________________________________
Theory:
MD5 (Message Digest Algorithm 5) is a widely used cryptographic hash function that produces a
128-bit hash value from input data. Designed by Ronald Rivest in 1991, MD5 is commonly used
for data integrity verification and checksums. It processes input data in 512-bit blocks, resulting
in a fixed-size 128-bit hash value. Despite its popularity, MD5 is now considered
cryptographically broken and unsuitable for security purposes due to vulnerabilities such as
susceptibility to collision attacks, where different inputs produce the same hash. As a result,
MD5 is largely replaced by more secure hashing algorithms like SHA-256 in modern
applications.
Source Code: [Link]
import hashlib
def md5_hash(message):
"""Compute the MD5 hash of a given message."""
# Create an MD5 hash object
md5 = hashlib.md5()
# Update the hash object with the bytes of the message
[Link]([Link]('utf-8'))
# Get the hexadecimal representation of the digest
hash_value = [Link]()
return hash_value
# Example usage
message = "The weather is gloomy"
print("Original Message:", message)
hash_value = md5_hash(message)
print("MD5 Hash:", hash_value)
Subject - Network Security and Cryptography 19
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 07
Aim - Implement Cryptographic Algorithm MD5. Tools/Technologies:
Cryptographic Libraries, Programming Languages and Hashing
Utilities.
__________________________________________________________________
Output: [Link]
Subject - Network Security and Cryptography 20
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 08
Aim - Implement Cryptographic Algorithm SHA-1. Tools/Technologies:
Cryptographic Libraries, Programming Languages and Hashing
Utilities.
__________________________________________________________________
Theory:
SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function designed by the NSA and
published by NIST in 1993. It produces a 160-bit hash value from input data, typically
represented as a 40-digit hexadecimal number. SHA-1 processes data in 512-bit blocks,
generating a fixed-size 160-bit hash. Initially used for data integrity and digital signatures,
SHA-1 is now considered weak due to vulnerabilities, including susceptibility to collision attacks
where different inputs generate the same hash. As a result, SHA-1 has been deprecated in favour
of more secure algorithms like SHA-256, which provide stronger cryptographic security.
Source Code: [Link]
import hashlib
def sha1_hash(message):
"""Compute the SHA-1 hash of a given message."""
# Create a SHA-1 hash object
sha1 = hashlib.sha1()
# Update the hash object with the bytes of the message
[Link]([Link]('utf-8'))
# Get the hexadecimal representation of the digest
hash_value = [Link]()
return hash_value
# Example usage
message = "Sunshine and Moonlight"
print("Original Message:", message)
hash_value = sha1_hash(message)
print("SHA-1 Hash:", hash_value)
Subject - Network Security and Cryptography 21
Name - Shaikh Juveria Shafi Ahmed Roll No. - SY MSc CS 05
Practical No. - 08
Aim - Implement Cryptographic Algorithm SHA-1. Tools/Technologies:
Cryptographic Libraries, Programming Languages and Hashing
Utilities.
__________________________________________________________________
Output: [Link]
Subject - Network Security and Cryptography 22
