SAGE University
Indore
Institute of Advance computing
Lab Manual File
Academic Year: - 2023-2024
Semester: Fourth
Name of Student: Omkar Datey EnrollmentNo: 22ADV3CSF0011
Subject Name : Cryptography using Python
Subject Code : ACTDECWP005T/P
Lab Manual: Cryptography using Python
Topic:- Asymetric Encryption
Objectives:
1. Understand the principles of asymmetric encryption.
2. Learn how to generate public and private keys.
3. Encrypt and decrypt messages using RSA.
Prerequisites:
Python 3.x installed on your computer.
cryptography library installed. Install using pip install cryptography.
Lab Setup:
1. Install Required Libraries:
pip install pycryptodome
Sections:
1. Introduction to Asymmetric Encryption
2. Key Generation
3. Encryption
4. Decryption
1. Introduction to Asymmetric Encryption
Asymmetric encryption uses two different keys for encryption and decryption.
The public key is used for encryption, and the private key is used for decryption.
RSA (Rivest-Shamir-Adleman) is one of the most widely used asymmetric
encryption algorithms.
2. Key Generation
To perform RSA encryption, you first need to generate a pair of keys: one public
and one private.
from Crypto.PublicKey import RSA
# Generate RSA key pair
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()
# Save the keys to files
with open('private.pem', 'wb') as priv_file:
priv_file.write(private_key)
with open('public.pem', 'wb') as pub_file:
pub_file.write(public_key)
print("Keys generated and saved to files.")
Output:-
Public Key
Private Key
3. Encryption
Using the public key, you can encrypt a message.
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from base64 import b64encode
# Load public key
with open('public.pem', 'rb') as pub_file:
public_key = RSA.import_key(pub_file.read())
# Message to be encrypted
message = "This is a secret message."
# Encrypt the message
cipher_rsa = PKCS1_OAEP.new(public_key)
encrypted_message = cipher_rsa.encrypt(message.encode())
# Encode the encrypted message in base64 for readability
encrypted_message_base64 = b64encode(encrypted_message)
print("Encrypted message:", encrypted_message_base64.decode())
Output
4. Decryption
Using the private key, you can decrypt the ciphertext back to the original message.
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from base64 import b64decode
# Function to add padding to base64 string
def add_padding(base64_string):
return base64_string + '=' * (-len(base64_string) % 4)
# Load private key
with open('private.pem', 'rb') as priv_file:
private_key = RSA.import_key(priv_file.read())
# Encrypted message (base64 encoded)
encrypted_message_base64 = "<place your base64 encoded encrypted message here>"
encrypted_message_base64 = add_padding(encrypted_message_base64) # Add padding if
necessary
encrypted_message = b64decode(encrypted_message_base64)
# Decrypt the message
cipher_rsa = PKCS1_OAEP.new(private_key)
decrypted_message = cipher_rsa.decrypt(encrypted_message)
print("Decrypted message:", decrypted_message.decode())
Output
Project 01
Topic:- Login Page which stores password as Hash in
database match it fir login access
(HTML and CSS):-
By Using some images and animation in css following is the login page and
signup page is created also we are using XAMPP server for testing and
database :-
Signup page:-
After Login Access redirected to a Welcome page:-
Practice Question:-
# 1. Write a Python code to print all available hashing algorithms?
import hashlib
print(hashlib.algorithms_available)
$OUTPUT-
# 2. Write a Python code to create a word dictionary using the
alphabet 'a', 'b', 'c', 'd' with a length of 5?
import itertools
# Define the alphabet and word length
alphabet = 'abcd'
word_length = 5
# Use itertools.product to generate all combinations
combinations = itertools.product(alphabet, repeat=word_length)
# Create the word dictionary
word_dict = {''.join(combination): None for combination in
combinations}
# Optionally, if you need the dictionary to hold some values, you can
initialize it differently, e.g., with a count or some default value
# word_dict = {''.join(combination): 0 for combination in
combinations}
# Print the number of words in the dictionary to verify
print(f"Number of words in the dictionary: {len(word_dict)}")
# Print the first 10 words as a sample
for i, word in enumerate(word_dict):
if i < 10:
print(word)
else:
break
$OUTPUT-
# 3. Write a program to convert the string 'MD5 HASH' to a hash using
the md5 hashing algorithm?
import hashlib
print(hashlib.md5(b'Hello World').hexdigest())
$OUTPUT-
# 4. Write a program to store the hash and salt using the PBKDF2_HMAC
algorithm?
import hashlib
import os
import base64
def generate_salt(length=16):
"""Generate a random salt."""
return os.urandom(length)
def hash_password(password, salt, iterations=100000,
hash_name='sha256'):
"""Hash a password with the given salt using PBKDF2_HMAC."""
password_bytes = password.encode('utf-8') # Convert the password
to bytes
dk = hashlib.pbkdf2_hmac(hash_name, password_bytes, salt,
iterations)
return dk
def store_password(password, iterations=100000, hash_name='sha256'):
"""Generate salt and hash the password, then store them."""
salt = generate_salt()
hash_bytes = hash_password(password, salt, iterations, hash_name)
# Encode salt and hash for storage (e.g., in a database)
salt_b64 = base64.b64encode(salt).decode('utf-8')
hash_b64 = base64.b64encode(hash_bytes).decode('utf-8')
return salt_b64, hash_b64
def verify_password(stored_password, provided_password, stored_salt,
iterations=100000, hash_name='sha256'):
"""Verify a provided password against the stored hash and salt."""
salt = base64.b64decode(stored_salt.encode('utf-8'))
stored_hash = base64.b64decode(stored_password.encode('utf-8'))
provided_hash = hash_password(provided_password, salt, iterations,
hash_name)
return provided_hash == stored_hash
# Example usage:
password = "secure_password"
# Store the password
salt_b64, hash_b64 = store_password(password)
print("Salt (base64):", salt_b64)
print("Hash (base64):", hash_b64)
# Verify the password
is_valid = verify_password(hash_b64, password, salt_b64)
print("Password is valid:", is_valid)
# Verify with the wrong password
is_valid = verify_password(hash_b64, "wrong_password", salt_b64)
print("Password is valid:", is_valid)
$OUTPUT-
# 5. Write a program to convert the string 'sha hash' to a hash using
the sha256 hashing algorithm?
import hashlib
print(hashlib.sha256(b'Hello World').hexdigest())
$OUTPUT-
# 6. Write a program to convert the string 'cryptography' to a hash
using the SHA-512 hashing algorithm?
import hashlib
print(hashlib.sha512(b'cryptography').hexdigest())
$OUTPUT-
# 7. Write a program to convert the string 'hello world' to a hash
using the sha3_512 hashing algorithm
import hashlib
print(hashlib.sha3_512(b'hello World').hexdigest())
$OUTPUT-
# 8. Write a program to convert the string 'black2b hash' to a hash
using the blake2b hashing algorithm?
import hashlib
print(hashlib.blake2b(b'black2b hash').hexdigest())
$OUTPUT-
# 9. write a program for Add a User & password with pbkdf2_hmac?
import hashlib
import os
import base64
import json
def generate_salt(length=16):
"""Generate a random salt."""
return os.urandom(length)
def hash_password(password, salt, iterations=100000,
hash_name='sha256'):
"""Hash a password with the given salt using PBKDF2_HMAC."""
password_bytes = password.encode('utf-8') # Convert the password
to bytes
dk = hashlib.pbkdf2_hmac(hash_name, password_bytes, salt,
iterations)
return dk
def add_user(username, password, user_db, iterations=100000,
hash_name='sha256'):
"""Add a new user with a hashed password to the user database."""
salt = generate_salt()
hash_bytes = hash_password(password, salt, iterations, hash_name)
# Encode salt and hash for storage
salt_b64 = base64.b64encode(salt).decode('utf-8')
hash_b64 = base64.b64encode(hash_bytes).decode('utf-8')
# Store the username, salt, and hash in the database
user_db[username] = {
'salt': salt_b64,
'hash': hash_b64,
'iterations': iterations,
'hash_name': hash_name
}
def save_user_db(user_db, filename='user_db.json'):
"""Save the user database to a file."""
with open(filename, 'w') as f:
json.dump(user_db, f)
def load_user_db(filename='user_db.json'):
"""Load the user database from a file."""
try:
with open(filename, 'r') as f:
return json.load(f)
except FileNotFoundError:
return {}
def main():
user_db = load_user_db()
print("Add a new user")
username = input("Enter username: ")
password = input("Enter password: ")
add_user(username, password, user_db)
save_user_db(user_db)
print(f"User '{username}' added successfully!")
if __name__ == "__main__":
main()
$OUTPUT-
# 10. write a python code on shift variable?
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
in_string = input("Enter message, Hint HELLO: ")
shift = int(input("Enter a shift number :"))
n = len(in_string)
out_string = ""
for i in range(n):
c = in_string[i]
loc = alpha.find(c.upper())
new_loc = loc + shift
if new_loc >= 26:
new_loc -= 26
out_string += alpha[new_loc]
print (i, c, loc, new_loc, out_string)
print ("Output After Encryption :", out_string)
$OUTPUT-
# 11. Write a Python code to print all available hashing Algorithm
Guaranteed?
import hashlib
print(hashlib.algorithms_guaranteed)
$OUTPUT-
# 12. Write a program to convert the string '128 hashing' to a hash
using the shake_128 hashing algorithm?
import hashlib
print(hashlib.shake_128(b'128 hashing').hexdigest(20))
$OUTPUT-
# 13. Write a program for password verification attempt with
(incorrect password or correct password) using any hashing algorithm?
import hashlib
import os
import base64
import json
def generate_salt(length=16):
"""Generate a random salt."""
return os.urandom(length)
def hash_password(password, salt, iterations=100000,
hash_name='sha256'):
"""Hash a password with the given salt using PBKDF2_HMAC."""
password_bytes = password.encode('utf-8') # Convert the password
to bytes
dk = hashlib.pbkdf2_hmac(hash_name, password_bytes, salt,
iterations)
return dk
def add_user(username, password, user_db, iterations=100000,
hash_name='sha256'):
"""Add a new user with a hashed password to the user database."""
salt = generate_salt()
hash_bytes = hash_password(password, salt, iterations, hash_name)
# Encode salt and hash for storage
salt_b64 = base64.b64encode(salt).decode('utf-8')
hash_b64 = base64.b64encode(hash_bytes).decode('utf-8')
# Store the username, salt, and hash in the database
user_db[username] = {
'salt': salt_b64,
'hash': hash_b64,
'iterations': iterations,
'hash_name': hash_name
}
def verify_password(stored_password, provided_password, stored_salt,
iterations=100000, hash_name='sha256'):
"""Verify a provided password against the stored hash and salt."""
salt = base64.b64decode(stored_salt.encode('utf-8'))
stored_hash = base64.b64decode(stored_password.encode('utf-8'))
provided_hash = hash_password(provided_password, salt, iterations,
hash_name)
return provided_hash == stored_hash
def save_user_db(user_db, filename='user_db.json'):
"""Save the user database to a file."""
with open(filename, 'w') as f:
json.dump(user_db, f)
def load_user_db(filename='user_db.json'):
"""Load the user database from a file."""
try:
with open(filename, 'r') as f:
return json.load(f)
except FileNotFoundError:
return {}
def main():
user_db = load_user_db()
while True:
action = input("Do you want to add a user (add) or verify a
password (verify)? ").strip().lower()
if action == 'add':
username = input("Enter username: ").strip()
password = input("Enter password: ").strip()
add_user(username, password, user_db)
save_user_db(user_db)
print(f"User '{username}' added successfully!")
elif action == 'verify':
username = input("Enter username: ").strip()
password = input("Enter password: ").strip()
if username in user_db:
stored_data = user_db[username]
is_valid = verify_password(
stored_data['hash'], password,
stored_data['salt'],
stored_data['iterations'],
stored_data['hash_name']
)
if is_valid:
print("Password is correct!")
else:
print("Password is incorrect!")
else:
print("Username not found.")
else:
print("Invalid action. Please enter 'add' or 'verify'.")
if __name__ == "__main__":
main()
$OUTPUT-
# 14. Write a program to convert the string 'crypto world' to a hash
using the sha3_224 hashing algorithm?
import hashlib
print(hashlib.sha3_224(b'crypto world').hexdigest())
$OUTPUT-
# 15. Write a program to convert the string 'crypto' to a hash using
the sha3_384 hashing algorithm ?
import hashlib
print(hashlib.sha3_384(b'crypto').hexdigest())
$OUTPUT-
# 16. Write a program to convert the string 'sha1 hash' to a hash
using the sha1 hashing algorithm ?
import hashlib
print(hashlib.sha1(b'sha1 hash').hexdigest())
$OUTPUT-
#17 Write a Python code to encrypt 'test.jpeg' using AES encryption ?
import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms,
modes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric import padding as
asym_padding
# Generate a random key and IV
def generate_key_iv(password, salt):
kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32,
salt=salt,
iterations=100000,
backend=default_backend()
)
key = kdf.derive(password)
iv = os.urandom(16)
return key, iv
# Encrypt the file
def encrypt_file(input_file, output_file, key, iv):
cipher = Cipher(algorithms.AES(key), modes.CBC(iv),
backend=default_backend())
encryptor = cipher.encryptor()
padder = padding.PKCS7(algorithms.AES.block_size).padder()
with open(input_file, 'rb') as f:
file_data = f.read()
padded_data = padder.update(file_data) + padder.finalize()
encrypted_data = encryptor.update(padded_data) +
encryptor.finalize()
with open(output_file, 'wb') as f:
f.write(iv + encrypted_data) # Prepend IV for use in
decryption
def main():
password = b'my_strong_password'
salt = os.urandom(16) # You should save this salt to use during
decryption
key, iv = generate_key_iv(password, salt)
input_file = 'test.jpeg'
output_file = 'test_encrypted.jpeg'
encrypt_file(input_file, output_file, key, iv)
print(f"File '{input_file}' has been encrypted and saved as
'{output_file}'.")
if __name__ == "__main__":
main()
# 18. Write a program to convert the string 'crypto world' to a hash
using the sha3_256 hashing algorithm ?
import hashlib
print(hashlib.sha3_256(b'crypto world').hexdigest())
$OUTPUT-
# 20. Write a program to convert the string 'cryptography' to a hash
using the shake_256 hashing algorithm ?
import hashlib
print(hashlib.shake_256(b'cryptography').hexdigest(20))
$OUTPUT-
# 22. Write a program to convert the string 'cryptography' to a hash
using the shake_256 hashing algorithm ?
import hashlib
print(hashlib.shake_256(b'cryptography').hexdigest(20))
$OUTPUT-
