S.

NO PROGRAM DATE REMARK

1 Program to find GCD of any two

numbers a and b mod n by Generalized
Euclidean Algorithm
2 Program to find Multiplicative Inverse of
b in Zp, p prime by Generalized
Euclidean Algorithm
3 Program to encrypt and decrypt by
Ceaser Cipher

4 Program to Encrypt and Decrypt by

Affine Cipher

5 Program to encrypt plaintext by Playfair

Cipher

6 Program to generate addition and

multiplication table for GF(22 ) Field
7 Program for key expansion algorithm of
DES

8 Program to implement 4*4 S-box and

perform two functionalities:
a.) Check given table of S-box and
inverse S-box are invertible to each
other.
b.) Ask the user to enter input to be
given in S-box and return its output.

9 Program to implement encryption and

decryption of RSA algorithm

INDEX
 PROGRAM 1

Aim:- Program to find GCD of any two numbers a and b mod n by Generalized Euclidean
Algorithm

CODE:-
def extended_gcd(a, b):

if a == 0:

return b, 0, 1

else:

gcd, x, y = extended_gcd(b % a, a)

return gcd, y - (b // a) * x, x

def gcd_mod(a, b, n):

gcd, x, y = extended_gcd(a, b)

if gcd != 1:

return None # Modular inverse does not exist

else:

return (x % n + n) % n

a = int(input("Enter first number: "))

b = int(input("Enter second number: "))

n = int(input("Enter modulo value: "))

gcd_modulus = gcd_mod(a, b, n)

if gcd_modulus is None:

print("Modular inverse does not exist.")

else:
 print("GCD of", a, "and", b, "modulo", n, "is", gcd_modulus)

OUTPUT:-
 PROGRAM 2

AIM:- Program to find Multiplicative Inverse of b in Zp, p prime by Generalized

Euclidean Algorithm

CODE:-
def extended_gcd(a, b):

if a == 0:

return b, 0, 1

else:

gcd, x, y = extended_gcd(b % a, a)

return gcd, y - (b // a) * x, x

def multiplicative_inverse(b, p):

gcd, x, y = extended_gcd(b, p)

if gcd != 1:

return None # Multiplicative inverse does not exist

else:

return (x % p + p) % p

b = int(input("Enter the number: "))

p = int(input("Enter the prime number: "))

inverse = multiplicative_inverse(b, p)

if inverse is None:

print("Multiplicative inverse does not exist.")

else:

print("Multiplicative inverse of", b, "in Z", p, "is", inverse)

OUTPUT:-
 PROGRAM 3

AIM:- Program to encrypt and decrypt by Ceaser Cipher

CODE:-
def encrypt(text, shift):

result = ""

for char in text:

if char.isupper():

result += chr((ord(char) + shift - 65) % 26 + 65)

elif char.islower():

result += chr((ord(char) + shift - 97) % 26 + 97)

else:

result += char

return result

def decrypt(text, shift):

return encrypt(text, -shift)

text = input("Enter the message: ")

shift = int(input("Enter the shift value: "))

encrypted_text = encrypt(text, shift)

print("Encrypted message:", encrypted_text)

decrypted_text = decrypt(encrypted_text, shift)

print("Decrypted message:", decrypted_text)

OUTPUT:-
 PROGRAM 4

AIM:- Program to Encrypt and Decrypt by Affine Cipher

CODE:-
def egcd(a, b):

if a == 0:

return (b, 0, 1)

else:

g, y, x = egcd(b % a, a)

return (g, x - (b // a) * y, y)

def modinv(a, m):

g, x, y = egcd(a, m)

if g != 1:

raise Exception('Modular inverse does not exist')

else:

return x % m

def encrypt(text, a, b):

result = ""

for char in text:

if char.isalpha():

if char.isupper():

result += chr((a * (ord(char) - 65) + b) % 26 + 65)

elif char.islower():

result += chr((a * (ord(char) - 97) + b) % 26 + 97)

else:
 result += char

return result

def decrypt(text, a, b):

inv_a = modinv(a, 26)

result = ""

for char in text:

if char.isalpha():

if char.isupper():

result += chr((inv_a * (ord(char) - 65 - b)) % 26 + 65)

elif char.islower():

result += chr((inv_a * (ord(char) - 97 - b)) % 26 + 97)

else:

result += char

return result

text = input("Enter the message: ")

a = int(input("Enter the value of 'a' (must be coprime with 26): "))

b = int(input("Enter the value of 'b': "))

encrypted_text = encrypt(text, a, b)

print("Encrypted message:", encrypted_text)

decrypted_text = decrypt(encrypted_text, a, b)

print("Decrypted message:", decrypted_text)

OUTPUT:-
 PROGRAM 5

AIM:- Program to encrypt plaintext by Playfair Cipher

CODE:-
def generate_key_square(key):

key = key.replace(" ", "").upper()

key_square = ""

for char in key:

if char not in key_square:

key_square += char

for i in range(65, 91):

if chr(i) not in key_square:

key_square += chr(i)

return key_square

def prepare_text(plaintext):

plaintext = plaintext.replace(" ", "").upper()

plaintext = plaintext.replace("J", "I")

prepared_text = ""

i=0

while i < len(plaintext):

prepared_text += plaintext[i]

if i + 1 < len(plaintext) and plaintext[i] == plaintext[i + 1]:

prepared_text += "X"

i += 1

if len(prepared_text) % 2 != 0:

prepared_text += "X"
 return prepared_text

def find_position(key_square, letter):

row = 0

col = 0

for i in range(5):

for j in range(5):

if key_square[5 * i + j] == letter:

row = i

col = j

break

return row, col

def encrypt(plaintext, key):

key_square = generate_key_square(key)

plaintext = prepare_text(plaintext)

ciphertext = ""

for i in range(0, len(plaintext), 2):

char1 = plaintext[i]

char2 = plaintext[i + 1]

row1, col1 = find_position(key_square, char1)

row2, col2 = find_position(key_square, char2)

if row1 == row2:

ciphertext += key_square[row1 * 5 + (col1 + 1) % 5]

ciphertext += key_square[row2 * 5 + (col2 + 1) % 5]

elif col1 == col2:

ciphertext += key_square[((row1 + 1) % 5) * 5 + col1]

ciphertext += key_square[((row2 + 1) % 5) * 5 + col2]

else:
 ciphertext += key_square[row1 * 5 + col2]

ciphertext += key_square[row2 * 5 + col1]

return ciphertext

plaintext = input("Enter the plaintext: ")

key = input("Enter the key: ")

ciphertext = encrypt(plaintext, key)

print("Encrypted text:", ciphertext)

OUTPUT:-
 PROGRAM 6

AIM:- Program to generate addition and multiplication table for GF(22 ) Field

CODE:-
def add_GF2(x, y):

return x ^ y

def mul_GF2(x, y):

result = 0

while y:

if y & 1:

result ^= x

y >>= 1

x <<= 1

if x & 0b100:

x ^= 0b101

return result

def generate_addition_table():

print("Addition Table for GF(2^2):")

print("| + | 0 | 1 | a | b |")

print("|---|----|----|----|----|")

for i in range(4):

print(f"| {format(i, 'x')} |", end=" ")

for j in range(4):

print(format(add_GF2(i, j), 'x').rjust(2), "|", end=" ")

print()
def generate_multiplication_table():

print("\nMultiplication Table for GF(2^2):")

print("| x | 0 | 1 | a | b |")

print("|---|----|----|----|----|")

for i in range(4):

print(f"| {format(i, 'x')} |", end=" ")

for j in range(4):

print(format(mul_GF2(i, j), 'x').rjust(2), "|", end=" ")

print()

generate_addition_table()

generate_multiplication_table()

OUTPUT:-
 PROGRAM 7

AIM:- Program for key expansion algorithm of DES

CODE:-
def left_shift(key, bits):
shifted_key = (key << bits) & 0xFFFFFFFFFFFFFFFF
overflow = shifted_key >> 56
return (shifted_key | overflow) & 0xFFFFFFFFFFFFFFFF

def generate_subkeys(key):
# PC-1
pc1_table = [
57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4
]

# PC-2
pc2_table = [
14, 17, 11, 24, 1, 5,
 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32
]

# Apply PC-1
key_permuted = 0
for i in range(56):
key_permuted |= (key >> (64 - pc1_table[i])) & 0x01
key_permuted <<= 1

key_permuted >>= 1

# Split key into left and right halves

c = (key_permuted >> 28) & 0x0FFFFFFF
d = key_permuted & 0x0FFFFFFF

subkeys = []
for i in range(16):
c = left_shift(c, 2 if i in [0, 1, 8, 15] else 1)
d = left_shift(d, 2 if i in [0, 1, 8, 15] else 1)
 # Apply PC-2
subkey = 0
for j in range(48):
subkey |= ((c if j < 28 else d) >> (56 - pc2_table[j])) & 0x01
subkey <<= 1

subkey >>= 1
subkeys.append(subkey)

return subkeys

def main():
key = int(input("Enter the 64-bit key in hexadecimal: "), 16)

subkeys = generate_subkeys(key)

print("\nGenerated 16 Round Keys:")

for i, subkey in enumerate(subkeys):
print(f"Round {i + 1}: {format(subkey, '048b')} (hex: {format(subkey,
'012x')})")

if __name__ == "__main__":
main()
OUTPUT:-
 PROGRAM 8

AIM:- Program to implement 4*4 S-box and perform two functionalities:

a.) Check given table of S-box and inverse S-box are invertible to each other.
b.) Ask the user to enter input to be given in S-box and return its output.

a.) Check given table of S-box and inverse S-box are invertible to each other.
CODE:-
def create_s_box():

s_box = [

[0x9, 0x4, 0xa, 0xb],

[0xd, 0x1, 0x8, 0x5],

[0x6, 0x2, 0x0, 0x3],

[0xc, 0xe, 0xf, 0x7]

return s_box

def create_inverse_s_box():

s_box = create_s_box()

inverse_s_box = [[0] * 4 for _ in range(4)]

for i in range(4):

for j in range(4):

inverse_s_box[s_box[i][j] >> 2][s_box[i][j] & 0x3] = i << 2 | j

return inverse_s_box

def check_invertibility(s_box, inverse_s_box):

for i in range(4):

for j in range(4):
 if s_box[i][j] != inverse_s_box[i][j]:

return False

return True

def main():

s_box = create_s_box()

inverse_s_box = create_inverse_s_box()

print("S-box:")

for row in s_box:

print(row)

print("\nInverse S-box:")

for row in inverse_s_box:

print(row)

if check_invertibility(s_box, inverse_s_box):

print("\nThe given S-box and its inverse are invertible to each other.")

else:

print("\nThe given S-box and its inverse are not invertible to each other.")

if __name__ == "__main__":

main()
OUTPUT:-
B)Ask the user to enter input to be given in S-box and return its output.

CODE:-
# Define the S-box

s_box = [

[0b1100, 0b0000, 0b0011, 0b1111],

[0b1101, 0b0111, 0b1110, 0b0010],

[0b0001, 0b1010, 0b1000, 0b0100],

[0b0110, 0b1001, 0b0101, 0b1011]

def s_box_lookup(input):

row = (input & 0b1100) >> 2

col = input & 0b0011

return s_box[row][col]

def main():

input_value = int(input("Enter 4-bit input (in binary): "), 2)

output_value = s_box_lookup(input_value)

print("Output from S-box:", format(output_value, '04b'))

if __name__ == "__main__":

main()
OUTPUT:-
 PROGRAM 9

AIM:- Program to implement encryption and decryption of RSA algorithm

CODE:-
import random
def is_prime(n, k=5):
if n <= 1:
return False
if n <= 3:
return True
for _ in range(k):
a = random.randint(2, n - 1)
if pow(a, n - 1, n) != 1:
return False
return True
def generate_prime(bits):
while True:
p = random.getrandbits(bits)
if is_prime(p):
return p
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def multiplicative_inverse(e, phi):
 d=0
x1, x2 = 0, 1
y1, y2 = 1, 0
temp_phi = phi

while e > 0:
temp1 = temp_phi // e
temp2 = temp_phi - temp1 * e
temp_phi = e
e = temp2
x = x2 - temp1 * x1
y = y2 - temp1 * y1
x2 = x1
x1 = x
y2 = y1
y1 = y
if temp_phi == 1:
return y2 + phi

def generate_keypair(p, q):

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 = multiplicative_inverse(e, phi)
return ((e, n), (d, n))
def encrypt(public_key, plaintext):
key, n = public_key
cipher = [pow(ord(char), key, n) for char in plaintext]
return cipher
def decrypt(private_key, ciphertext):
key, n = private_key
plain = [chr(pow(char, key, n)) for char in ciphertext]
return ''.join(plain)
def main():
# Generate two random prime numbers
p = generate_prime(64)
q = generate_prime(64)
# Generate public and private keys
public_key, private_key = generate_keypair(p, q)
print("Public Key:", public_key)
print("Private Key:", private_key)
# Input plaintext message
message = input("Enter the message to be encrypted: ")
# Encrypt the message
encrypted_message = encrypt(public_key, message)
print("Encrypted message:", encrypted_message)
# Decrypt the message
 decrypted_message = decrypt(private_key, encrypted_message)
print("Decrypted message:", decrypted_message)
if __name__ == "__main__":
main()

OUTPUT:-