Ceaser Cipher
plaintext = input("Enter the plaintext: ")
k = int(input("Enter the key value: "))
cipher = {}
initial_ascii_cap = 65
initial_ascii_low = 97
# Create mapping for uppercase letters
for i in range(26):
char = chr(initial_ascii_cap + i)
cipher[char] = i
# Create mapping for lowercase letters
for i in range(26):
char = chr(initial_ascii_low + i)
cipher[char] = i
cip = ''
for j in plaintext:
if j.isalpha():
updatedval = cipher[j] + k
updatedval %= 26
if j.islower():
c = chr(updatedval + initial_ascii_low)
else:
c = chr(updatedval + initial_ascii_cap)
cip += c
else:
cip += j # Non-alphabetic characters remain unchanged
print(cip)
hill cipher
import numpy as np
def mod_inverse(a, m):
for x in range(1, m):
if (a * x) % m == 1:
return x
return None
def ttn(text): # text to numbers
return [ord(char) - ord('A') for char in text.upper() if char.isalpha()]
def ntt(numbers): # numbers to text
return ''.join(chr(num + ord('A')) for num in numbers)
def pad_text(text, size):
padding_length = (size - len(text) % size) % size
return text + 'X' * padding_length
def encryption(pt, key):
n = len(key)
pt = pad_text(pt, n)
pt_n = ttn(pt)
cipher = []
for i in range(0, len(pt_n), n):
block = pt_n[i:i+n]
enc_block = np.dot(key, block) % 26
cipher.extend(enc_block)
return ntt(cipher)
def decryption(c, key):
n = len(key)
det = int(round(np.linalg.det(key)))
det_inv = mod_inverse(det % 26, 26)
if det_inv is None:
raise ValueError("Modular inverse doesn't exist; invalid key matrix.")
key_inverse = (
det_inv * np.round(det * np.linalg.inv(key)).astype(int) % 26
) % 26
cipher = ttn(c)
pt_n = []
for i in range(0, len(cipher), n):
block = cipher[i:i+n]
dec_block = np.dot(key_inverse, block) % 26
pt_n.extend(dec_block)
return ntt(pt_n).rstrip('X')
# Example usage
key_m = np.array([[6, 24, 1], [13, 16, 10], [20, 17, 15]])
pt = "HELLO"
enc = encryption(pt, key_m)
print(f"Encrypted = {enc}")
dec = decryption(enc, key_m)
print(f"Decrypted = {dec}")
Vignete cipher
plaintext = input("Enter the plaintext: ")
key = input("Enter the key value: ")
cipher = {}
initial_ascii_cap = 65
initial_ascii_low = 97
# Create alphabet to index mappings
for i in range(26):
cipher[chr(initial_ascii_cap + i)] = i
cipher[chr(initial_ascii_low + i)] = i
cip = ''
vals = []
vals2 = []
# Convert plaintext to values
for j in plaintext:
if j.isalpha():
val = cipher[j]
vals.append(val)
else:
vals.append(j) # Store non-alphabetic characters as-is
# Extend or repeat the key
extended_key = ''
key_index = 0
for ch in plaintext:
if ch.isalpha():
extended_key += key[key_index % len(key)]
key_index += 1
else:
extended_key += ch
# Convert key to values
for j in extended_key:
if j.isalpha():
val = cipher[j]
vals2.append(val)
else:
vals2.append(j)
# Perform encryption
for i in range(len(vals)):
if isinstance(vals[i], int):
new_val = (vals[i] + vals2[i]) % 26
if plaintext[i].islower():
c = chr(new_val + initial_ascii_low)
else:
c = chr(new_val + initial_ascii_cap)
cip += c
else:
cip += vals[i] # Non-alphabetic characters unchanged
print(cip)
playfair cipher
def generate_playfair_matrix(key):
key = key.upper().replace("J", "I")
matrix = []
seen = set()
for char in key + "ABCDEFGHIKLMNOPQRSTUVWXYZ":
if char not in seen:
seen.add(char)
matrix.append(char)
return [matrix[i:i+5] for i in range(0, 25, 5)]
def find_position(matrix, char):
for i in range(5):
for j in range(5):
if matrix[i][j] == char:
return i, j
return None
def prepare_text(text):
text = text.upper().replace("J", "I")
prepared = ""
i=0
while i < len(text):
char1 = text[i]
char2 = text[i + 1] if i + 1 < len(text) else 'X'
if char1 == char2:
prepared += char1 + 'X'
i += 1
else:
prepared += char1 + char2
i += 2
if len(prepared) % 2 != 0:
prepared += 'X'
return prepared
def playfair_encrypt(text, key):
matrix = generate_playfair_matrix(key)
text = prepare_text(text)
encrypted = ""
for i in range(0, len(text), 2):
row1, col1 = find_position(matrix, text[i])
row2, col2 = find_position(matrix, text[i + 1])
if row1 == row2: # Same row
encrypted += matrix[row1][(col1 + 1) % 5]
encrypted += matrix[row2][(col2 + 1) % 5]
elif col1 == col2: # Same column
encrypted += matrix[(row1 + 1) % 5][col1]
encrypted += matrix[(row2 + 1) % 5][col2]
else: # Rectangle swap
encrypted += matrix[row1][col2]
encrypted += matrix[row2][col1]
return encrypted
def playfair_decrypt(text, key):
matrix = generate_playfair_matrix(key)
decrypted = ""
for i in range(0, len(text), 2):
row1, col1 = find_position(matrix, text[i])
row2, col2 = find_position(matrix, text[i + 1])
if row1 == row2: # Same row
decrypted += matrix[row1][(col1 - 1) % 5]
decrypted += matrix[row2][(col2 - 1) % 5]
elif col1 == col2: # Same column
decrypted += matrix[(row1 - 1) % 5][col1]
decrypted += matrix[(row2 - 1) % 5][col2]
else: # Rectangle swap
decrypted += matrix[row1][col2]
decrypted += matrix[row2][col1]
return decrypted
RSA
import random
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def modinv(a, m):
m0, x0, x1 = m, 0, 1
if m == 1:
return 0
while a > 1:
q = a // m
m, a = a % m, m
x0, x1 = x1 - q * x0, x0
if x1 < 0:
x1 += m0
return x1
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True
def generate_keypair(p, q):
if not (is_prime(p) and is_prime(q)):
raise ValueError("Both numbers must be prime.")
elif p == q:
raise ValueError("p and q cannot be the same")
n=p*q
phi = (p - 1) * (q - 1)
e = random.randrange(1, phi)
g = gcd(e, phi)
while g != 1:
e = random.randrange(1, phi)
g = gcd(e, phi)
d = modinv(e, phi)
return ((e, n), (d, n))
def encrypt(pk, plaintext):
key, n = pk
cipher = [(ord(char) ** key) % n for char in plaintext]
return cipher
def decrypt(pk, ciphertext):
key, n = pk
plain = [chr((char ** key) % n) for char in ciphertext]
return ''.join(plain)
if __name__ == '__main__':
p = 61
q = 53
public, private = generate_keypair(p, q)
print("Public key:", public)
print("Private key:", private)
message = input("Enter the message you want to encrypt: ")
encrypted_msg = encrypt(public, message)
print("Encrypted message:", encrypted_msg)
decrypted_msg = decrypt(private, encrypted_msg)
print("Decrypted message:", decrypted_msg)
dewie hellman
import random
def gen_keys(p, g):
a = random.randint(1, p - 1)
A = pow(g, a, p)
return a, A
def compute_sk(a, B, p):
return pow(B, a, p)
p = 23
g=5
a, A = gen_keys(p, g)
b, B = gen_keys(p, g)
shared_key_a = compute_sk(a, B, p)
shared_key_b = compute_sk(b, A, p)
print(shared_key_a == shared_key_b)
print("Shared key:", shared_key_a)
Elgamal
import random
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def mod_exp(base, exp, mod):
result = 1
while exp > 0:
if exp % 2 == 1:
result = (result * base) % mod
base = (base * base) % mod
exp //= 2
return result
def generate_keys(p):
g = random.randint(2, p - 1)
x = random.randint(1, p - 2)
h = mod_exp(g, x, p)
return (p, g, h), x
def encrypt(public_key, plaintext):
p, g, h = public_key
y = random.randint(1, p - 2)
c1 = mod_exp(g, y, p)
c2 = (plaintext * mod_exp(h, y, p)) % p
return c1, c2
def decrypt(private_key, public_key, ciphertext):
p, g, h = public_key
c1, c2 = ciphertext
s = mod_exp(c1, private_key, p)
s_inv = pow(s, -1, p)
plaintext = (c2 * s_inv) % p
return plaintext
p = 467 # A large prime
public_key, private_key = generate_keys(p)
print("Public Key:", public_key)
print("Private Key:", private_key)
plaintext = 123
ciphertext = encrypt(public_key, plaintext)
print("Ciphertext:", ciphertext)
decrypted_message = decrypt(private_key, public_key, ciphertext)
print("Decrypted Message:", decrypted_message)
RSA question
def gcd(a, b):
while b:
a, b = b, a % b
return a
def modinv(e, phi):
d_old, d = 0, 1
r_old, r = phi, e
while r != 0:
q = r_old // r
r_old, r = r, r_old - q * r
d_old, d = d, d_old - q * d
return d_old % phi
def rsa_encrypt_decrypt(p, q, e, M):
n=p*q
phi = (p - 1) * (q - 1)
d = modinv(e, phi)
C = pow(M, e, n)
decrypted = pow(C, d, n)
return {
"n": n, "phi": phi, "e": e, "d": d,
"Encrypted (C)": C, "Decrypted (M)": decrypted
test_cases = [
(3, 7, 5, 10),
(5, 13, 5, 8),
(7, 17, 11, 11),
(7, 13, 11, 2),
(17, 23, 9, 7)
for i, (p, q, e, M) in enumerate(test_cases, start=1):
result = rsa_encrypt_decrypt(p, q, e, M)
print(f"\nCase {chr(96+i)}) p={p}, q={q}, e={e}, M={M}")
print(f" n = {result['n']}, phi = {result['phi']}, d = {result['d']}")
print(f" Encrypted (C) = {result['Encrypted (C)']}")
print(f" Decrypted (M) = {result['Decrypted (M)']}")
dewie hellman backup
def mod_exp(base, exp, mod):
result = 1
base = base % mod
while exp > 0:
if exp % 2 == 1:
result = (result * base) % mod
base = (base * base) % mod
exp //= 2
return result
# Input
alpha = int(input("Enter alpha (primitive root): "))
q = int(input("Enter prime number q: "))
xa = int(input("Enter private key of Alice (xa): "))
xb = int(input("Enter private key of Bob (xb): "))
# Public keys
ya = mod_exp(alpha, xa, q) # Alice's public key
yb = mod_exp(alpha, xb, q) # Bob's public key
# Secret keys
ka = mod_exp(yb, xa, q) # Secret key calculated by Alice
kb = mod_exp(ya, xb, q) # Secret key calculated by Bob
# Output
print("\n--- Diwie-Hellman Key Exchange ---")
print(f"Alpha = {alpha}")
print(f"q = {q}")
print(f"Private key of Alice = {xa}")
print(f"Public key of Alice = {ya}")
print(f"Private key of Bob = {xb}")
print(f"Public key of Bob = {yb}")
print(f"Secret key computed by Alice = {ka}")
print(f"Secret key computed by Bob = {kb}")
if ka == kb:
print("✅ Both Alice and Bob have the same secret key.")
print("🔐 Key shared securely.")
else:
print("❌ Key is not shared securely.")
SHA
print("Sample Result")
n = int(input("Give the number of bits for the message: "))
multiplier = 1
while multiplier * 1024 < (n + 128):
multiplier += 1
padding_size = (multiplier * 1024) - (n + 128)
print("\nOriginal message length (bits):", n)
print("The size of the padding bits is:", padding_size)
print("The total size of the blocks after including the padding bits is:", padding_size + n +
128)
# Create padding bits string: '1' followed by (padding_size - 1) zeros
paddingBitsString = '1' + '0' * (padding_size - 1)
print("The padding bits are as below, along with the number of bits (excluding the size of the
message {128}):")
print(paddingBitsString)
print("Size of padding bits:", len(paddingBitsString))
print("Total blocks required:", multiplier)
MD5
def itos(n):
return '0' if n == 0 else '1'
def dec_to_binary(n):
res = ""
count = 8
i=n
while i != 0 or count > 0:
if i == 0 and len(res) < 8:
res = res.rjust(8, '0')
return res
res = itos(i % 2) + res
i //= 2
count -= 1
return res
def main():
inp = input("Give the original message to check: ")
n = len(inp)
input_chain = []
padding_chain = []
print("1. Showing the original message in binary:")
for ch in inp:
temp = dec_to_binary(ord(ch))
print(temp, end=" ")
input_chain.append(temp)
total_message_bits = n * 8
print(f"\nThe total message bits size: {total_message_bits}")
i=1
while (512 * i) - 64 - total_message_bits < 0:
i += 1
x = (512 * i) - 64 - total_message_bits
print(f"\n2. The total number of padding bits is: {x}")
message_length = dec_to_binary(total_message_bits)
print("Message length in binary:", message_length)
# Padding: starts with '10000000' (i.e., 0x80) followed by required 0 blocks
padding_chain.append("10000000")
padding_blocks = x // 8
temp = padding_blocks - 1
while temp != 0:
padding_chain.append("00000000")
temp -= 1
print("The number of padding blocks is (without the message size block):",
padding_blocks)
print("3. The padding bits are:")
for b in padding_chain:
print(b, end=" ")
print(f"\nThe Message in bits are below (The size of the message is:
{total_message_bits}):")
for bit_block in input_chain:
print(bit_block, end=" ")
if __name__ == "__main__":
main()
AES KEY EXP
s_box = [
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7,
0xAB,….
]
rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36]
def rot_word(word):
return word[1:] + word[:1]
def sub_word(word):
return [s_box[b] for b in word]
def key_expansion(key):
key_size = len(key)
assert key_size == 16
expanded = []
for i in range(0, 16, 4):
word = list(key[i:i+4])
expanded.append(word)
for i in range(4, 44):
temp = expanded[i - 1].copy()
if i % 4 == 0:
temp = rot_word(temp)
temp = sub_word(temp)
temp[0] ^= rcon[(i // 4) - 1]
new_word = [temp[j] ^ expanded[i - 4][j] for j in range(4)]
expanded.append(new_word)
return expanded
sample_key = bytes.fromhex("4A1A607DD64C444F6B2750E0975FE72E")
expanded_keys = key_expansion(sample_key)
round4_key = expanded_keys[16:20]
round4_key_bytes = bytes([byte for word in round4_key for byte in word])
print("Round4 Key (hex):", round4_key_bytes.hex().upper())
DES simulation
def permutation(input_block, table):
output = 0
for i, pos in enumerate(table):
bit = (input_block >> (64 - pos)) & 1
output |= bit << (64 - (i + 1))
return output
ip_table = [
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,…
fp_table = [
40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23,…
input_hex = "0001002000000008".replace(" ", "")
input_block = int(input_hex, 16)
ip_result = permutation(input_block, ip_table)
fp_result = permutation(ip_result, fp_table)
print("Input block: " + format(input_block, '016X'))
print("After Initial Perm.: " + format(ip_result, '016X'))
print("After Final Perm.: " + format(fp_result, '016X'))
SHA da
def print_hex_vector(vec):
for i, val in enumerate(vec):
print(f"W{i} = {val:016X}")
def majority(a, b, c):
return (a & b) ^ (a & c) ^ (b & c)
def condition(e, f, g):
return (e & f) ^ (~e & g)
# === (1) User input message ===
message = input("Enter the plaintext message: ")
msg_bytes = message.encode("utf-8")
original_bit_length = len(msg_bytes) * 8
# === (a) Padding bits calculation ===
padding_bits = (1024 - (original_bit_length + 1 + 128) % 1024) % 1024
print(f"\n(a) Padding bits: {padding_bits}")
# === (b) Generate message schedule (W0 to W17) ===
W = [0] * 80
for i in range(len(msg_bytes)):
W[i // 8] |= msg_bytes[i] << ((7 - (i % 8)) * 8)
# Append 1 bit (0x80)
W[len(msg_bytes) // 8] |= 0x80 << ((7 - (len(msg_bytes) % 8)) * 8)
# Append original length to W[15]
W[15] = original_bit_length
# Extend W[16] to W[17]
for i in range(16, 18):
W[i] = W[i - 16] + W[i - 7]
print("\n(b) First 18 words (W0 - W17) in hex:")
print_hex_vector(W[:18])
# === (c) Majority function ===
A = 0x6a09e667f3bcc908
B = 0xbb67ae8584caa73b
C = 0x3c6ef372fe94f82b
majority_result = majority(A, B, C)
print(f"\n(c) Majority function result: {majority_result:016X}")
# === (d) Condition function ===
E = 0x510e527fade682d1
F = 0x9b05688c2b3e6c1f
G = 0x1f83d9abfb41bd6b
condition_result = condition(E, F, G)
print(f"(d) Condition function result: {condition_result:016X}")
Absolutely! Here's a brief algorithmic description for each of the provided code snippets:
1. Caesar Cipher:
• Input: Plaintext string, shift key (integer).
• Process:
o Iterate through each character of the plaintext.
o If the character is alphabetic:
§ Convert the character to its corresponding numerical value (A=0,
B=1, etc.).
§ Add the shift key to the numerical value.
§ Apply modulo 26 to wrap around the alphabet.
§ Convert the resulting numerical value back to a character.
o If the character is not alphabetic, leave it unchanged.
• Output: Ciphertext string.
2. Hill Cipher:
• Input: Plaintext string, key matrix (numpy array).
• Process:
o Pad the plaintext with 'X' characters to make its length a multiple of the
key matrix size.
o Convert the plaintext to numerical values (A=0, B=1, etc.).
o Divide the numerical plaintext into blocks of size equal to the key matrix
size.
o For each block:
§ Multiply the key matrix by the block (vector multiplication).
§ Apply modulo 26 to the result.
o Convert the resulting numerical values back to characters.
• Output: Ciphertext string.
• Decryption:
o Calculate the inverse of the Key Matrix.
o Perform the encryption steps in reverse.
3. Vigenère Cipher:
• Input: Plaintext string, key string.
• Process:
o Extend the key to match the plaintext length (repeating the key).
o Convert both plaintext and extended key to numerical values (A=0, B=1,
etc.).
o For each character:
§ Add the plaintext numerical value to the corresponding key
numerical value.
§ Apply modulo 26 to the result.
§ Convert the resulting numerical value back to a character.
o Non alphabetic characters are not changed.
• Output: Ciphertext string.
4. Playfair Cipher:
• Input: Plaintext string, key string.
• Process:
o Generate a 5x5 key matrix from the key (replacing 'J' with 'I').
o Prepare the plaintext:
§ Replace 'J' with 'I'.
§ Insert 'X' between repeated letters.
§ Pad with 'X' if the plaintext length is odd.
o Divide the plaintext into pairs of characters.
o For each pair:
§ Find the positions of the characters in the key matrix.
§ Apply the Playfair rules (same row, same column, rectangle) to get
the ciphertext pair.
o Convert the ciphertext pairs back to a string.
• Output: Ciphertext string.
• Decryption:
o Reverse the encryption steps.
5. RSA:
• Input: Two prime numbers (p, q), plaintext message.
• Process:
o Generate public and private keys:
§ n=p*q
§ phi = (p-1) * (q-1)
§ Choose public exponent 'e' (relatively prime to phi).
§ Calculate private exponent 'd' (modular inverse of 'e' mod phi).
o Encryption:
§ Convert plaintext characters to numerical values.
§ Ciphertext = (plaintext ^ e) mod n.
o Decryption:
§ Plaintext = (ciphertext ^ d) mod n.
• Output: Ciphertext (numerical list), decrypted plaintext.
6. Diffie-Hellman:
• Input: Prime number (p), generator (g), private keys (a, b).
• Process:
o Calculate public keys:
§ A = g^a mod p
§ B = g^b mod p
o Calculate shared secret keys:
§ ka = B^a mod p
§ kb = A^b mod p
• Output: Shared secret key.
7. ElGamal:
• Input: Prime number (p), plaintext message.
• Process:
o Key generation:
§ Generate a generator g.
§ Generate a private key x.
§ Generate a public key h = g^x mod p.
o Encryption:
§ Generate a random y.
§ c1 = g^y mod p.
§ c2 = plaintext * h^y mod p.
o Decryption:
§ s = c1^x mod p.
§ plaintext = c2 * s^-1 mod p.
• Output: Ciphertext (c1, c2), decrypted plaintext.
8. RSA Question (Encryption/Decryption Function):
• Input: Two prime numbers (p, q), public exponent (e), message (M).
• Process:
o Calculate n = p * q and phi = (p-1) * (q-1).
oCalculate private exponent d (modular inverse of e mod phi).
oEncryption: C = M^e mod n.
oDecryption: M = C^d mod n.
• Output: n, phi, d, encrypted message (C), decrypted message (M).
9. Diffie-Hellman Backup:
• Input: primitive root alpha, prime number q, private keys xa and xb.
• Process:
o calculate public keys ya and yb.
o calculate shared key ka and kb.
• Output: public keys, and shared secret key.
10. SHA:
• Input: Message (string).
• Process:
o Calculate padding bits needed.
o Append the padding bits to the message.
o Append the original message lenght in bits.
o Show the result.
• Output: padded message information.
11. MD5:
• Input: Message string.
• Process:
o Convert message to binary.
o Calculate the number of padding bits.
o Append the padding bits.
o Append message length in bits.
• Output: padded message information.
12. AES Key Expansion:
• Input: 16-byte key.
• Process:
o Expand the key into a 44-word array.
o Use S-box, Rcon, and rotation operations.
• Output: Expanded key array.
13. DES Simulation:
• Input: 64-bit input block.
• Process:
o Apply initial permutation (IP).
o Apply final permutation (FP).
• Output: Permuted blocks.
14. SHA da:
• Input: Message string.
• Process:
o Calculate padding bits.
o Create message schedule (W array).
o Perform majority and condition operations.
• Output: intermediate hash values.
