cryptodome-lab 0.1.0__tar.gz

cryptodome_lab-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: cryptodome-lab
+Version: 0.1.0
+Summary: Menu-based viewer for original cryptography practical materials
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# cryptodome-lab
+
+A simple menu-based viewer for practical materials in the supplied ZIP. The name is inspired by the `Crypto.Cipher` imports found in some source practicals; this is an independent educational viewer and is not affiliated with PyCryptodome.
+
+The original DOCX/PDF files are included byte-for-byte unchanged. Text files are extracted from those documents for output viewing. Extraction may omit formatting, images, and code shown only inside screenshots. The viewer displays material; it does not execute the practical steps.
+
+## Run locally
+From the folder containing `pyproject.toml`:
+```cmd
+python -m pip install .
+python -m cryptodome_lab
+```
+
+## Build and upload
+```cmd
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```

cryptodome_lab-0.1.0/README.md

@@ -0,0 +1,20 @@
+# cryptodome-lab
+
+A simple menu-based viewer for practical materials in the supplied ZIP. The name is inspired by the `Crypto.Cipher` imports found in some source practicals; this is an independent educational viewer and is not affiliated with PyCryptodome.
+
+The original DOCX/PDF files are included byte-for-byte unchanged. Text files are extracted from those documents for output viewing. Extraction may omit formatting, images, and code shown only inside screenshots. The viewer displays material; it does not execute the practical steps.
+
+## Run locally
+From the folder containing `pyproject.toml`:
+```cmd
+python -m pip install .
+python -m cryptodome_lab
+```
+
+## Build and upload
+```cmd
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```

cryptodome_lab-0.1.0/cryptodome_lab/__init__.py

@@ -0,0 +1 @@
+"""Menu-based viewer for original cryptography practical materials."""

cryptodome_lab-0.1.0/cryptodome_lab/__main__.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+PRACTICALS_DIR = Path(__file__).parent / "practicals"
+
+def main():
+    practicals = sorted(PRACTICALS_DIR.glob("*.txt"))
+    if not practicals:
+        print("No practical text files were found.")
+        return
+
+    while True:
+        print("\\n=== CryptoDome Lab: Practical Viewer ===")
+        for number, path in enumerate(practicals, 1):
+            print(f"{number}. {path.stem.replace('_', ' ')}")
+        print("0. Exit")
+
+        choice = input("\\nEnter practical number to view: ").strip()
+        if choice == "0":
+            print("Exiting CryptoDome Lab.")
+            break
+        if not choice.isdigit() or not 1 <= int(choice) <= len(practicals):
+            print("Invalid choice. Try again.")
+            continue
+
+        path = practicals[int(choice) - 1]
+        print("\\n" + "=" * 72)
+        print(path.stem.replace("_", " "))
+        print("=" * 72 + "\\n")
+        print(path.read_text(encoding="utf-8"))
+        input("\\nPress Enter to return to the menu...")
+
+if __name__ == "__main__":
+    main()

cryptodome_lab-0.1.0/cryptodome_lab/practicals/Classical_Cryptography_Project_Documentation.txt

@@ -0,0 +1,99 @@
+CLASSICAL CRYPTOGRAPHY PROJECT
+Implementation, Encryption, Decryption & Cipher Analysis
+Project Documentation
+Python-based implementation of classical encryption techniques
+1. Project Overview
+The project is a classical cryptography demonstration system implemented in Python. It provides encryption and decryption functions for multiple historical ciphers and allows the same plaintext to be processed through different algorithms for comparison. The implementation also measures characteristics of the resulting ciphertext, including execution time, chi-squared score, index of coincidence, Shannon entropy, and an estimated key-space size.
+The code is organized as reusable functions and an Enigma class. Input validation is included for important parameters such as cipher keys, offsets, rotor settings, and Hill cipher matrices.
+2. Ciphers Implemented
+3. Caesar Cipher and ROT13
+Caesar Cipher
+The Caesar implementation applies a fixed shift to each alphabetic character. Uppercase and lowercase letters are preserved, while non-alphabetic characters remain unchanged. Decryption uses the same transformation with the negative of the encryption shift.
+The project also includes a brute-force function that tries all 26 possible Caesar shifts.
+ROT13
+ROT13 is implemented as a Caesar transformation with a fixed shift of 13. Because shifting by 13 twice returns to the original letter, the same ROT13 operation can be used in both directions.
+4. Vigenere Cipher
+The Vigenere cipher uses a repeating alphabetic key. For each alphabetic character, the corresponding key character determines the shift. The key index advances only when an alphabetic character is processed, while spaces and other non-alphabetic characters are preserved.
+For decryption, the key shift is subtracted instead of added. The implementation validates that the key is non-empty and contains only alphabetic characters.
+5. One-Time Pad (OTP)
+The OTP implementation applies a different key character to each alphabetic character of the plaintext. The key must be at least as long as the number of alphabetic characters in the message; otherwise the program raises an error. The implementation also provides a random key-generation helper.
+The generated random key is intended for the class demonstration in this project; the source code itself notes that a cryptographic secrets source would be preferred for real security.
+6. Playfair Cipher
+The Playfair implementation builds a 5×5 key matrix. The letter J is merged with I, producing a 25-letter square. The keyword is placed first without duplicates, followed by the remaining alphabet letters.
+Before encryption, the plaintext is converted to uppercase letters, J is changed to I, and the message is divided into pairs. If a pair contains duplicate letters, an X is inserted between them. An X is also added if the final letter has no partner.
+For each pair, the code applies the standard Playfair rules: letters in the same row move right, letters in the same column move down, and letters forming a rectangle exchange columns. Decryption reverses the row and column movements.
+7. Hill Cipher
+The Hill cipher implementation converts a four-letter key into a 2×2 numerical matrix using A=0 through Z=25. Plaintext is processed in pairs and multiplied by the matrix modulo 26.
+A key is valid only when the matrix is invertible modulo 26. The implementation checks the determinant and requires the determinant to be relatively prime to 26. Decryption uses the modular inverse of the key matrix.
+If the number of alphabetic characters is odd, the implementation pads the message with X before processing.
+8. Enigma Cipher
+The Enigma implementation is represented by an Enigma class. It uses three selectable rotors, each with a fixed wiring, and a reflector. The supported rotor wirings in the project are Rotor I, Rotor II and Rotor III.
+The machine is initialized with a rotor order and three starting positions. Before every alphabetic character is processed, the rotors step. The right rotor advances for each letter, and notch conditions control when the middle and left rotors advance.
+During encryption, the character travels from the right rotor to the middle rotor and then the left rotor, enters the reflector, and then travels backward through the left, middle and right rotors. The rotor-position adjustment is included in both the forward and backward transformations.
+Enigma is reciprocal in this implementation. Therefore, a fresh machine with the same rotor order and starting positions can process the ciphertext again to recover the original plaintext.
+9. Wheel / Jefferson Disk Cipher
+The Wheel cipher implementation uses multiple shuffled alphabet disks. Six disks are used by default. The disks are generated from a keyword; the keyword and disk number are used to initialize the random generator, so the same keyword recreates the same disk arrangement.
+During encryption, the program selects disks cyclically. For each alphabetic character, it finds the character's position on the selected disk, adds the specified offset modulo 26, and outputs the character at the new position.
+Decryption regenerates the same disks using the keyword and subtracts the same offset. Non-alphabetic characters are preserved.
+10. Ciphertext Analysis
+Letter Frequency
+The project counts occurrences of A–Z characters in a case-insensitive manner. This frequency information is used by the statistical analysis functions.
+Chi-Squared Score
+The chi-squared score compares observed letter frequencies with standard English frequencies. The implementation uses a lower score to indicate a ciphertext distribution that resembles natural English more closely.
+Index of Coincidence
+The Index of Coincidence measures how frequently pairs of letters are likely to match. The source documentation notes that values around 0.067 resemble natural English while lower values can indicate a more uniform distribution.
+Shannon Entropy
+Shannon entropy is calculated in bits per character using the A–Z distribution. The maximum possible entropy for a 26-letter alphabet is approximately log2(26), or 4.70 bits per character. Higher entropy represents greater unpredictability in the observed distribution.
+Execution Time and Key Space
+The project measures execution time using a high-resolution performance timer. It also records an estimated key-space size in bits for the implemented ciphers. For example, Caesar has 26 possible shifts, while the Wheel configuration uses six permutations of a 26-letter alphabet.
+11. Common Comparison Function
+The compare_all function processes the same plaintext through the selected ciphers and creates a common result row for each cipher. Each row contains the cipher name, ciphertext, execution time, chi-squared score, index of coincidence, entropy, and key-space information.
+This makes it possible to compare different classical techniques using consistent measurements rather than looking only at the encrypted text.
+12. Testing and Validation
+The project includes a main test section that encrypts a sample message with every implemented cipher and then decrypts it. For the reversible cases, assertions are used to verify that the original plaintext is recovered.
+The source test section ends with a message indicating that all round-trip tests passed when the expected results are obtained.
+13. Program Structure
+14. Conclusion
+This project demonstrates how different classical cryptographic techniques transform plaintext into ciphertext using different mathematical and mechanical ideas. The project covers simple substitution, polyalphabetic encryption, pair-based methods, matrix-based encryption, rotor-based encryption, and disk-based encryption.
+Beyond encryption and decryption, the project provides a practical comparison layer using execution time, statistical characteristics, entropy, and key-space estimates. The included round-trip tests provide a basic functional validation of the implementations.
+The project is intended as an educational demonstration of classical cryptography and comparative cipher analysis rather than as a replacement for modern cryptographic standards.
+
+[TABLE 1]
+Project Area | Details
+Programming Language | Python
+Main Objective | Implement and compare classical cryptographic ciphers
+Encryption Modes | Caesar, ROT13, Vigenere, OTP, Playfair, Hill, Enigma, Wheel/Jefferson Disk
+Analysis | Chi-squared score, Index of Coincidence, Shannon entropy, timing and key-space comparison
+Validation | Round-trip encryption/decryption tests
+
+[TABLE 2]
+Cipher | Basic Principle | Key / Setting
+Caesar | Shifts alphabetic characters by a fixed amount. | Integer shift
+ROT13 | Special Caesar transformation using a fixed 13-position shift. | No variable key
+Vigenere | Uses repeating key letters to apply changing Caesar shifts. | Alphabetic key
+One-Time Pad (OTP) | Applies a key-dependent shift to each alphabetic character. | Key at least as long as message letters
+Playfair | Encrypts pairs of letters using a 5×5 key square. | Alphabetic keyword
+Hill | Encrypts pairs using a 2×2 matrix modulo 26. | Exactly four letters; matrix must be invertible
+Enigma | Uses three rotors, a reflector, and changing rotor positions. | Rotor order + starting positions
+Wheel / Jefferson Disk | Uses shuffled alphabet disks and a position offset. | Keyword + offset
+
+[TABLE 3]
+Tested Component | Validation
+Caesar | Encrypt then decrypt and compare with original sample
+ROT13 | Apply ROT13 twice and compare with original
+Vigenere | Encrypt and decrypt using the same key
+OTP | Encrypt and decrypt using the generated key
+Playfair | Encrypt and decrypt using the same keyword
+Hill | Generate a valid key, encrypt, decrypt, and inspect the result
+Enigma | Process ciphertext again using the same rotor settings
+Wheel | Encrypt and decrypt using the same keyword and offset
+
+[TABLE 4]
+Component | Responsibility
+Cipher functions | Provide independent encryption/decryption implementations.
+Enigma class | Maintains rotor wiring, positions, stepping, and character processing.
+Statistical analysis | Calculates frequency, chi-squared, coincidence, and entropy metrics.
+Timing helper | Measures execution time of a cipher operation.
+Comparison function | Runs selected ciphers on the same plaintext and collects common metrics.
+Validation / errors | Checks keys, lengths, types, and valid Hill matrices.
+Main test section | Runs sample round-trip tests for the implemented algorithms.

cryptodome_lab-0.1.0/cryptodome_lab/practicals/Deff_Hell_INS_PRAC6.txt

@@ -0,0 +1,36 @@
+PRACTICAL NO:6
+        DIFFIE-HELLMAN KEY EXCHANGE ALGORITHM
+Diffie-Hellman is a mathematical problem that is the foundation for many cryptographic protocols. Diffie-Hellman is one of the greatest inventions in Cybersecurity. This revolutionary algorithm was proposed by Whitfield Diffie and Martin Hellman in 1976, enabling two entities to agree upon a secret key without prior arrangements, even in the presence of potential eavesdroppers. Diffie-Hellman offers a powerful solution to secure key exchange which has always been challenging and prone to alteration, thus ensuring confidentiality and integrity in information. 
+CODE:
+import random
+def power(base,exponent,mod):
+    result=1
+    base=base%mod
+    while exponent > 0:
+        if exponent % 2 == 1:
+            result=(result*base)%mod
+        exponent=exponent >> 1
+        base=(base*base) % mod
+    return result
+p=19
+g=5
+a_private=random.randint(1,p-2)
+a_public=power(g,a_private,p)
+b_private=random.randint(1,p-2)
+b_public=power(g,b_private,p)
+a_shared_key=power(b_public,a_private,p)
+b_shared_key=power(a_public,b_private,p)
+print("Public parameters:")
+print(f"Prime (p): {p}")
+print(f"Primitive root (g)|: {g} \n")
+print("Alice's private key:",a_private)
+print("Alice's public key:",a_public)
+print("Bob's private key:",b_private)
+print("Bob's public key:",b_public)
+print("\nShared key computed by Alice:",a_shared_key)
+print("Shared key computed by Bob:",b_shared_key)
+if a_shared_key == b_shared_key:
+    print("\nKey exchange successful!! Shared symmetric key established. ")
+else:
+    print("\nKey exchange failed. ")
+OUTPUT:

cryptodome_lab-0.1.0/cryptodome_lab/practicals/Encrypt_decrypt___Hashing_algo.txt

@@ -0,0 +1,38 @@
+Prac 1:-Encrypt and decrypt algo 
+Code:-
+def encrypt(text,s):
+    result=""
+    for i in range(len(text)):
+        char=text[i]
+        if (char.isupper()):
+            result+=chr((ord(char) + s-65) % 26 +65)
+        else:
+            result+=chr((ord(char) + s-97) % 26 +97)
+    return result
+def decrypt(text,s):
+    result=""
+    for i in range(len(text)):
+        char=text[i]
+        if (char.isupper()):
+            result+=chr((ord(char) - s-65) % 26 +65)
+        else:
+            result+=chr((ord(char) - s-97) % 26 +97)
+    return result
+text="attackontitan"
+s=5
+print("text is:",text)
+print("shift of:",s)
+print("encrypted result:",encrypt(text,s))
+de=encrypt(text,s)
+print(decrypt(de,s))
+Output:-
+2.Hashing
+import bcrypt
+pwd=b'Mypass'
+salt=bcrypt.gensalt()
+hashed=bcrypt.hashpw(pwd,salt)
+print("Salt :")
+print(salt)
+print("Hashed")
+print(hashed)
+Output:-

cryptodome_lab-0.1.0/cryptodome_lab/practicals/INS_PRAC4_2.txt

@@ -0,0 +1,81 @@
+PRACTICAL NO: 4.2
+                                     AES
+CBC
+CODE:
+from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
+import base64
+def pad(data):
+    pad_len=16-(len(data)%16)
+    return data+chr(pad_len) * pad_len
+def unpad(data):
+    pad_len=ord(data[-1])
+    return data[:-pad_len]
+def encrypt_aes(palin_text,key):
+    iv=get_random_bytes(16)
+    cipher=AES.new(key,AES.MODE_CBC,iv)
+    padded_text=pad(palin_text)
+    encrypted=cipher.encrypt(padded_text.encode('utf-8'))
+    return base64.b64encode(iv+encrypted).decode('utf-8')
+def decrypt_aes(cipher_text,key):
+    raw=base64.b64decode(cipher_text)
+    iv=raw[:16]
+    encrypted=raw[16:]
+    cipher=AES.new(key,AES.MODE_CBC,iv)
+    decrypted=cipher.decrypt(encrypted).decode('utf-8')
+    return unpad(decrypted)
+if __name__=="__main__":
+    key=get_random_bytes(16)
+    print("AES key (base64):",base64.b64encode(key).decode("utf-8"))
+    msg="Hello,AES encryption!"
+    print("Original msg:",msg)
+    encrypted=encrypt_aes(msg,key)
+    print("Encrypted (Base64):",encrypted)
+    decrypted=decrypt_aes(encrypted,key)
+    print("Decrypted (Base64):",decrypted)
+OUTPUT:
+ECB
+CODE:
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad,unpad
+key=b'SixteenByteKey12'
+data=b'Secure Database Payload Data'
+cipher_encrypt=AES.new(key,AES.MODE_ECB)
+padded_data=pad(data,AES.block_size)
+ciphertext=cipher_encrypt.encrypt(padded_data)
+cipher_decrypt=AES.new(key,AES.MODE_ECB)
+decrypted_padded=cipher_decrypt.decrypt(ciphertext)
+original_data=unpad(decrypted_padded,AES.block_size)
+print(f"Ciphertext (Hex) : {ciphertext.hex()}")
+print(f"Decrypted Data: {original_data.decode()}")
+OUTPUT:
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Random import get_random_bytes
+# 16-byte AES key (AES-128)
+key = b"1234567890abcdef"
+# Generate a random IV
+iv = get_random_bytes(16)
+# ---------- Encryption ----------
+input_file = "C:/Users/Admin/Downloads/simple.txt"
+encrypted_file = "encrypted.bin"
+with open(input_file, "rb") as f:
+    plaintext = f.read()
+cipher = AES.new(key, AES.MODE_CBC, iv)
+ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
+with open(encrypted_file, "wb") as f:
+    # Store IV followed by ciphertext
+    f.write(iv)
+    f.write(ciphertext)
+print("File encrypted successfully as:", encrypted_file)
+# ---------- Decryption ----------
+decrypted_file = "decrypted_file"  
+with open(encrypted_file, "rb") as f:
+    iv = f.read(16)          # Read IV
+    ciphertext = f.read()    # Read ciphertext
+cipher = AES.new(key, AES.MODE_CBC, iv)
+decrypted_data = unpad(cipher.decrypt(ciphertext), AES.block_size)
+with open(decrypted_file, "wb") as f:
+    f.write(decrypted_data)
+print("File decrypted successfully as:", decrypted_file)
+Output:-

cryptodome_lab-0.1.0/cryptodome_lab/practicals/INS_PRAC4_2_1.txt

@@ -0,0 +1,51 @@
+PRACTICAL NO: 4.2
+                                     AES
+CBC
+CODE:
+from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
+import base64
+def pad(data):
+    pad_len=16-(len(data)%16)
+    return data+chr(pad_len) * pad_len
+def unpad(data):
+    pad_len=ord(data[-1])
+    return data[:-pad_len]
+def encrypt_aes(palin_text,key):
+    iv=get_random_bytes(16)
+    cipher=AES.new(key,AES.MODE_CBC,iv)
+    padded_text=pad(palin_text)
+    encrypted=cipher.encrypt(padded_text.encode('utf-8'))
+    return base64.b64encode(iv+encrypted).decode('utf-8')
+def decrypt_aes(cipher_text,key):
+    raw=base64.b64decode(cipher_text)
+    iv=raw[:16]
+    encrypted=raw[16:]
+    cipher=AES.new(key,AES.MODE_CBC,iv)
+    decrypted=cipher.decrypt(encrypted).decode('utf-8')
+    return unpad(decrypted)
+if __name__=="__main__":
+    key=get_random_bytes(16)
+    print("AES key (base64):",base64.b64encode(key).decode("utf-8"))
+    msg="Hello,AES encryption!"
+    print("Original msg:",msg)
+    encrypted=encrypt_aes(msg,key)
+    print("Encrypted (Base64):",encrypted)
+    decrypted=decrypt_aes(encrypted,key)
+    print("Decrypted (Base64):",decrypted)
+OUTPUT:
+ECB
+CODE:
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad,unpad
+key=b'SixteenByteKey12'
+data=b'Secure Database Payload Data'
+cipher_encrypt=AES.new(key,AES.MODE_ECB)
+padded_data=pad(data,AES.block_size)
+ciphertext=cipher_encrypt.encrypt(padded_data)
+cipher_decrypt=AES.new(key,AES.MODE_ECB)
+decrypted_padded=cipher_decrypt.decrypt(ciphertext)
+original_data=unpad(decrypted_padded,AES.block_size)
+print(f"Ciphertext (Hex) : {ciphertext.hex()}")
+print(f"Decrypted Data: {original_data.decode()}")
+OUTPUT:

cryptodome_lab-0.1.0/cryptodome_lab/practicals/INS_PRAC8.txt

@@ -0,0 +1,19 @@
+PRACTICAL NO:8
+                                     HMAC-SHA1
+Aim
+To write a Python program to calculate the HMAC-SHA1 (Hash-based Message Authentication Code using SHA-1) signature for a given message and secret key.
+Introduction
+HMAC stands for Hash-based Message Authentication Code. It is a mechanism used to verify the integrity and authenticity of a message. HMAC uses a cryptographic hash function together with a secret key. Both the sender and receiver must know the same secret key.
+HMAC-SHA1 uses the SHA-1 hash algorithm as its underlying hash function. The result of HMAC-SHA1 is a 160-bit (20-byte) message authentication code, normally displayed as 40 hexadecimal characters.
+Need for HMAC
+A normal hash function can detect accidental changes to data, but by itself it does not prove who generated the hash. An attacker who changes a message could also calculate a new ordinary hash. HMAC solves this problem by combining the message with a secret key that is known only to the communicating parties.
+HMAC-SHA1
+In HMAC-SHA1, SHA-1 is used as the hash function. The secret key is
+processed according to the HMAC construction and combined with the
+message using two fixed padding values called ipad and opad.
+8.1 
+CODE:
+OUTPUT:
+8.2
+CODE:
+OUTPUT:

cryptodome_lab-0.1.0/cryptodome_lab/practicals/PRACTICAL_NO_9.txt

@@ -0,0 +1,40 @@
+PRACTICAL NO:9
+                       OPENSSL IMPLEMENTATION
+1.open terminal run as admin 
+2.locate to bin folder of openssl
+3.run command 
+openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes
+4.cert.pem and key.pem is been created cut and paste in a same folder where server and client
+server.py
+import socket
+import ssl
+host = 'localhost'
+port = 8443
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+sock.bind((host, port))
+sock.listen(5)
+print(f"[*] Listening on https://{host}:{port}")
+context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+context.load_cert_chain(certfile="cert.pem", keyfile="key.pem")
+while True:
+    client_socket, addr = sock.accept()
+    print(f"[+] Connection from {addr}")
+    with context.wrap_socket(client_socket, server_side=True) as ssock:
+        data = ssock.recv(1024).decode()
+        print("[Client says]:", data)
+        ssock.sendall(b"Hello from secure server!")
+client.py
+import socket
+import ssl
+hostname = "localhost"
+port = 8443
+context = ssl.create_default_context()
+context.check_hostname = False
+context.verify_mode = ssl.CERT_NONE  # Allow self-signed certs
+with socket.create_connection((hostname, port)) as sock:
+    with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+        ssock.sendall(b"Hello secure server!")
+        print("[Server says]:", ssock.recv(1024).decode())
+All in same folder
+5.run server.py 
+6.run client.py

cryptodome_lab-0.1.0/cryptodome_lab/practicals/Prac2_Ins.txt

@@ -0,0 +1,70 @@
+Prac 2:Ins
+1.Vernam cipher
+ Code:-
+def vernam_encrypt(plaintext, key):
+    if len(plaintext)!=len(key):
+        raise ValueError("key must be same length as plaintext.")
+    return ''.join(chr(ord(p)^ ord(k)) for p,k in zip(plaintext,key))
+def vernam_decrypt(ciphertext,key):
+    return vernam_encrypt(ciphertext,key)
+plaintext=input("enter text to encrypt:")
+key=input("please enter key same length as text:")
+ciphertext=vernam_encrypt(plaintext,key)
+print("Encrypted:",ciphertext)
+decrypt=vernam_decrypt(ciphertext,key)
+print("Decrypted:",decrypt)
+Output:-
+2.Playfair cipher
+Code:-
+def prepare_key_matrix(key):
+    key=key.upper().replace("J","I")
+    seen=set()
+    key_matrix=[]
+    for char in key:
+        if char not in seen and char.isalpha():
+            seen.add(char)
+            key_matrix.append(char)
+    for char in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
+        if char not in seen:
+            seen.add(char)
+            key_matrix.append(char)
+    return [key_matrix[i:i+5] for i in range (0,25,5)]
+def find_position(matrix,char):
+    for row_idx,row in enumerate(matrix):
+        if char in row:
+            return row_idx,row.index(char)
+    return None,None
+def encrypt_digraph(digraph,matrix):
+    a,b=digraph
+    row1,col1=find_position(matrix, a)
+    row2,col2=find_position(matrix, b)
+    if row1== row2:
+        return matrix[row1][(col1 +1)%5] +matrix[row2][(col2 +1)%5]
+    elif col1 == col2:
+        return matrix[(row1 +1)%5][col1] +matrix[(row2+1)%5][col2]
+    else:
+        return matrix[row1][col2]+matrix[row2][col1]
+def prepare_plaintext(text)    :
+    text=text.upper().replace("J","I").replace(" ","")
+    cleaned=[]
+    i=0
+    while i<len(text):
+        a=text[i]
+        b=text[i+1] if i+1 <len(text) else "X"
+        if a==b:
+            cleaned.append(a +"X")
+            i+=1
+        else:
+            cleaned.append(a+b)
+            i+=2
+    if len(cleaned[-1]) ==1:
+        cleaned[-1] +="X"
+    return cleaned
+def playfair_encrypt(plaintext,key):
+    matrix=prepare_key_matrix(key)
+    digraphs=prepare_plaintext(plaintext)
+    ciphertext=''.join(encrypt_digraph(pair,matrix) for pair in digraphs)
+    return ciphertext
+cipher=playfair_encrypt("hell o","monarchy")
+print(cipher)
+Output:-

cryptodome_lab-0.1.0/cryptodome_lab/practicals/Prac5_RSA_Algorithm_INS_Assignment.txt

@@ -0,0 +1,94 @@
+Prac 5:RSA Algorithm
+Code:-
+def gcd(a,b):
+    while b:
+        a,b=b,a%b
+    return a
+def mod_inverse(e,phi):
+    for d in range(1,phi):
+        if (e*d)%phi==1:
+            return d
+    return None
+def encrypt(public_key,plaintext):
+    e,n=public_key
+    cipher=[pow(ord(char),e,n) for char in plaintext]
+    return cipher
+def decrypt(private_key,ciphertext):
+    d,n=private_key
+    plain=''.join(chr(pow(char,d,n))for char in ciphertext)
+    return plain
+p=61
+q=53
+n=p*q
+phi=(p-1)*(q-1)
+e=17
+while gcd(e,phi)!=1:
+    e+=2
+d=mod_inverse(e,phi)
+public_key=(e,n)
+private_key=(d,n)
+msg=input("Enter the message:")
+cipher_text=encrypt(public_key,msg)
+decrypted_text=decrypt(private_key,cipher_text)
+print("public key:",public_key)
+print("private key:",private_key)
+print(e)
+print("original msg:",msg)
+print("Encrypted:",cipher_text)
+print("Decrypted:",decrypted_text)
+Output:-
+RSA Assingment:-
+Code:-
+import hashlib
+def gcd(a,b):
+    while b:
+        a,b=b,a%b
+    return a
+def mod_inverse(e,phi):
+    for d in range(1,phi):
+        if (e*d)%phi==1:
+            return d
+    return None
+def encrypt(public_key,plaintext):
+    e,n=public_key
+    cipher=[pow(ord(char),e,n) for char in plaintext]
+    return cipher
+def decrypt(private_key,ciphertext):
+    d,n=private_key
+    plain=''.join(chr(pow(char,d,n))for char in ciphertext)
+    return plain
+p=61
+q=53
+n=p*q
+phi=(p-1)*(q-1)
+e=17
+while gcd(e,phi)!=1:
+    e+=2
+d=mod_inverse(e,phi)
+public_key=(e,n)
+private_key=(d,n)
+msg=input("Enter the msg:")
+cipher_text=encrypt(public_key,msg)
+decrypted_text=decrypt(private_key,cipher_text)
+print("public key:",public_key)
+print("private key:",private_key)
+print("original msg:",msg)
+print("Encrypted:",cipher_text)
+print("Decrypted:",decrypted_text)
+hash_hex = hashlib.sha256(msg.encode('utf-8')).hexdigest()
+hash_int = int(hash_hex, 16)
+# Truncate hash integer to fit within modular size n
+hash_int_mod = hash_int % n
+print(f"Original msg : '{msg}'")
+print(f"Full SHA-256 Hash: {hash_hex}")
+print(f"Hash Integer     : {hash_int}")
+print(f"Hash (mod n)     : {hash_int_mod}\n")
+signature = pow(hash_int_mod, d, n)
+print(f"Digital Signature: {signature}\n")
+decrypted_hash = pow(signature, e, n)
+print(f"Decrypted Hash   : {decrypted_hash}")
+if decrypted_hash == hash_int_mod:
+    print("Verification Result: SUCCESS - Signature is VALID!")
+else:
+    print("Verification Result: FAILED - Invalid signature or tampered message.")
+Output:-