Program-1

def caesar_cipher(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

text = "Hello, World!"

shift = 3

encrypted_text = caesar_cipher(text, shift)

print("Plain Text:",text)

print("Shift Pattern is:",shift)

print("Encrypted Text:", encrypted_text)

Program-2

import string

def caesar_cipher(text, shift, mode):

result = ""

if mode == "decrypt":

shift = -shift

for char in text:

if char.isupper():

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

elif char.islower():

# Shift the character and wrap around a-z if needed

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

else:
 result += char

return result

while True:

mode = input("Would you like to encrypt or decrypt a message? (Type 'encrypt' or 'decrypt'):
").lower()

if mode not in ["encrypt", "decrypt"]:

print("Invalid option. Please enter 'encrypt' or 'decrypt'.")

continue

try:

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

except ValueError:

print("Invalid shift value. Please enter an integer.")

continue

if mode == "encrypt":

text = input("Enter the message to encrypt: ")

encrypted_text = caesar_cipher(text, shift, mode)

print("Encrypted Message:", encrypted_text)

elif mode == "decrypt":

text = input("Enter the message to decrypt: ")

decrypted_text = caesar_cipher(text, shift, mode)

print("Decrypted Message:", decrypted_text)

another = input("Do you want to encrypt/decrypt another message? (yes/no): ").lower()

if another != "yes":

print("Exiting the program.")

break

Program-3

import hashlib

text = "GeeksforGeeks"

result = hashlib.sha256(text.encode())

print("The hexadecimal equivalent of SHA256 is:")

print(result.hexdigest())
result = hashlib.sha384(text.encode())

print("\nThe hexadecimal equivalent of SHA384 is:")

print(result.hexdigest())

result = hashlib.sha224(text.encode())

print("\nThe hexadecimal equivalent of SHA224 is:")

print(result.hexdigest())

result = hashlib.sha512(text.encode())

print("\nThe hexadecimal equivalent of SHA512 is:")

print(result.hexdigest())

result = hashlib.sha1(text.encode())

print("\nThe hexadecimal equivalent of SHA1 is:")

print(result.hexdigest())

Program-4

def hex2bin(s):

mp = {'0': "0000",

'1': "0001",

'2': "0010",

'3': "0011",

'4': "0100",

'5': "0101",

'6': "0110",

'7': "0111",

'8': "1000",

'9': "1001",

'A': "1010",

'B': "1011",

'C': "1100",

'D': "1101",

'E': "1110",

'F': "1111"}

bin = ""
 for i in range(len(s)):

bin = bin + mp[s[i]]

return bin

def bin2hex(s):

mp = {"0000": '0',

"0001": '1',

"0010": '2',

"0011": '3',

"0100": '4',

"0101": '5',

"0110": '6',

"0111": '7',

"1000": '8',

"1001": '9',

"1010": 'A',

"1011": 'B',

"1100": 'C',

"1101": 'D',

"1110": 'E',

"1111": 'F'}

hex = ""

for i in range(0, len(s), 4):

ch = ""

ch = ch + s[i]

ch = ch + s[i + 1]

ch = ch + s[i + 2]

ch = ch + s[i + 3]

hex = hex + mp[ch]

return hex
def bin2dec(binary):

binary1 = binary

decimal, i, n = 0, 0, 0

while(binary != 0):

dec = binary % 10

decimal = decimal + dec * pow(2, i)

binary = binary//10

i += 1

return decimal

def dec2bin(num):

res = bin(num).replace("0b", "")

if(len(res) % 4 != 0):

div = len(res) / 4

div = int(div)

counter = (4 * (div + 1)) - len(res)

for i in range(0, counter):

res = '0' + res

return res

def permute(k, arr, n):

permutation = ""

for i in range(0, n):

permutation = permutation + k[arr[i] - 1]

return permutation

def shift_left(k, nth_shifts):

s = ""

for i in range(nth_shifts):
 for j in range(1, len(k)):

s = s + k[j]

s = s + k[0]

k=s

s = ""

return k

def xor(a, b):

ans = ""

for i in range(len(a)):

if a[i] == b[i]:

ans = ans + "0"

else:

ans = ans + "1"

return ans

initial_perm = [58, 50, 42, 34, 26, 18, 10, 2,

60, 52, 44, 36, 28, 20, 12, 4,

62, 54, 46, 38, 30, 22, 14, 6,

64, 56, 48, 40, 32, 24, 16, 8,

57, 49, 41, 33, 25, 17, 9, 1,

59, 51, 43, 35, 27, 19, 11, 3,

61, 53, 45, 37, 29, 21, 13, 5,

63, 55, 47, 39, 31, 23, 15, 7]

exp_d = [32, 1, 2, 3, 4, 5, 4, 5,

6, 7, 8, 9, 8, 9, 10, 11,

12, 13, 12, 13, 14, 15, 16, 17,

16, 17, 18, 19, 20, 21, 20, 21,

22, 23, 24, 25, 24, 25, 26, 27,

28, 29, 28, 29, 30, 31, 32, 1]

29, 12, 28, 17,

1, 15, 23, 26,

5, 18, 31, 10,

2, 8, 24, 14,

32, 27, 3, 9,

19, 13, 30, 6,

22, 11, 4, 25]

sbox = [[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],

[0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],

[4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],

[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],

[[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],

[3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],

[0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],

[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],

[[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],

[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],

[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],

[1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],

[[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],

[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],

[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],

[3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],

[[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],

[4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],

[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],

[[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],

[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],

[9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],

[4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],

[[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],

[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],

[1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],

[6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],

[[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],

[1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],

[7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],

[2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]

final_perm = [40, 8, 48, 16, 56, 24, 64, 32,

39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30,

37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28,

35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26,

33, 1, 41, 9, 49, 17, 57, 25]

def encrypt(pt, rkb, rk):

pt = hex2bin(pt)
 pt = permute(pt, initial_perm, 64)

print("After initial permutation", bin2hex(pt))

left = pt[0:32]

right = pt[32:64]

for i in range(0, 16):

right_expanded = permute(right, exp_d, 48)

xor_x = xor(right_expanded, rkb[i])

sbox_str = ""

for j in range(0, 8):

row = bin2dec(int(xor_x[j * 6] + xor_x[j * 6 + 5]))

col = bin2dec(

int(xor_x[j * 6 + 1] + xor_x[j * 6 + 2] + xor_x[j * 6 + 3] + xor_x[j * 6 + 4]))

val = sbox[j][row][col]

sbox_str = sbox_str + dec2bin(val)

sbox_str = permute(sbox_str, per, 32)

result = xor(left, sbox_str)

left = result

if(i != 15):

left, right = right, left

print("Round ", i + 1, " ", bin2hex(left),

" ", bin2hex(right), " ", rk[i])

combine = left + right

cipher_text = permute(combine, final_perm, 64)

return cipher_text

pt = "123456ABCD132536"

key ="AABB09182736CCDD"

key = hex2bin(key)
keyp = [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]

key = permute(key, keyp, 56)

shift_table = [1, 1, 2, 2,

2, 2, 2, 2,

1, 2, 2, 2,

2, 2, 2, 1]

key_comp = [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]

left = key[0:28]

right = key[28:56]

rkb = []

rk = []

for i in range(0, 16):

right = shift_left(right, shift_table[i])

combine_str = left + right

round_key = permute(combine_str, key_comp, 48)

rkb.append(round_key)

rk.append(bin2hex(round_key))

print("Encryption")

cipher_text = bin2hex(encrypt(pt, rkb, rk))

print("Cipher Text : ", cipher_text)

print("Decryption")

rkb_rev = rkb[::-1]

rk_rev = rk[::-1]

text = bin2hex(encrypt(cipher_text, rkb_rev, rk_rev))

print("Plain Text : ", text)

Program-5

from Crypto.Cipher import AES

from Crypto.Random import get_random_bytes

import base64

def pad(text):

padding_len = 16 - (len(text) % 16)

padding = chr(padding_len) * padding_len

return text + padding

def unpad(text):

padding_len = ord(text[-1])

return text[:-padding_len]

def aes_encrypt(key, plaintext):

cipher = AES.new(key, AES.MODE_CBC, iv)

padded_text = pad(plaintext)

encrypted_text = cipher.encrypt(padded_text.encode())

return base64.b64encode(iv + encrypted_text).decode()

def aes_decrypt(key, ciphertext):

raw_data = base64.b64decode(ciphertext)

iv = raw_data[:16]

encrypted_text = raw_data[16:]

cipher = AES.new(key, AES.MODE_CBC, iv)

decrypted_text = cipher.decrypt(encrypted_text).decode()

return unpad(decrypted_text)

key = get_random_bytes(16)

print("Generated Key (base64):", base64.b64encode(key).decode())

plaintext = input("Enter the message to encrypt: ")

ciphertext = aes_encrypt(key, plaintext)

print("Encrypted Message:", ciphertext)

decrypted_message = aes_decrypt(key, ciphertext)

print("Decrypted Message:", decrypted_message)

Program-6

from math import gcd

def RSA(p: int, q: int, message: int):

n=p*q

t = (p - 1) * (q - 1)

for i in range(2, t):

if gcd(i, t) == 1:

e=i

break

j=0

while True:

if (j * e) % t == 1:
 d=j

break

j += 1

ct = (message ** e) % n

print(f"Encrypted message is {ct}")

mes = (ct ** d) % n

print(f"Decrypted message is {mes}")

RSA(p=53, q=59, message=89)

Program-7

import random

# public keys are taken

# p is a prime number

# g is a primitive root of p

p = int(input('Enter a prime number : '))

g = int(input('Enter a number : '))

class A:

def __init__(self):

# Generating a random private number selected by alice

self.n = random.randint(1, p)

def publish(self):

# generating public values

return (g**self.n)%p

def compute_secret(self, gb):

# computing secret key

return (gb**self.n)%p

class B:

def __init__(self):

# Generating a random private number selected for alice

self.a = random.randint(1, p)

# Generating a random private number selected for bob

self.arr = [self.a,self.b]

def publish(self, i):

# generating public values

return (g**self.arr[i])%p

def compute_secret(self, ga, i):

# computing secret key

return (ga**self.arr[i])%p

alice = A()

bob = A()

eve = B()

# Printing out the private selected number by Alice and Bob

print(f'Alice selected (a) : {alice.n}')

print(f'Bob selected (b) : {bob.n}')

print(f'Eve selected private number for Alice (c) : {eve.a}')

print(f'Eve selected private number for Bob (d) : {eve.b}')

# Generating public values

ga = alice.publish()

gb = bob.publish()

gea = eve.publish(0)

geb = eve.publish(1)

print(f'Alice published (ga): {ga}')

print(f'Bob published (gb): {gb}')

print(f'Eve published value for Alice (gc): {gea}')

print(f'Eve published value for Bob (gd): {geb}')

# Computing the secret key

sa = alice.compute_secret(gea)

sea = eve.compute_secret(ga,0)

sb = bob.compute_secret(geb)

seb = eve.compute_secret(gb,1)

print(f'Alice computed (S1) : {sa}')

print(f'Bob computed (S2) : {sb}')

print(f'Eve computed key for Bob (S2) : {seb}')

Program-8

from Crypto.PublicKey import RSA

from Crypto.Signature import pkcs1_15

from Crypto.Hash import SHA256

from Crypto.Random import get_random_bytes

# Generate RSA keys

key = RSA.generate(2048)

private_key = key.export_key()

public_key = key.publickey().export_key()

# Save the private and public keys to files

with open('private.pem', 'wb') as f:

f.write(private_key)

with open('public.pem', 'wb') as f:

f.write(public_key)

# Function to sign data

def sign_message(message, private_key):

# Import the private key

key = RSA.import_key(private_key)

# Create a hash of the message

h = SHA256.new(message.encode())

# Sign the hash

signature = pkcs1_15.new(key).sign(h)

return signature

# Function to verify signature

def verify_signature(message, signature, public_key):

# Import the public key

key = RSA.import_key(public_key)

# Create a hash of the message

try:

# Verify the signature

pkcs1_15.new(key).verify(h, signature)

return True

except (ValueError, TypeError):

return False

# Example usage

if __name__ == "__main__":

message = "This is a secret message."

# Sign the message

signature = sign_message(message, private_key)

print(f"Signature: {signature.hex()}")

# Verify the signature

is_valid = verify_signature(message, signature, public_key)

print(f"Signature valid: {is_valid}")

Program-9

import hashlib

import os

import socket

import ssl

import base64

from cryptography.fernet import Fernet

from getpass import getpass

# Sample list of known malicious app hashes

known_malicious_apps = [

"5d41402abc4b2a76b9719d911017c592", # example hash of a malicious app

# Function to scan installed apps for malicious software

def scan_for_malicious_apps(app_list):

malicious_apps = []
 for app in app_list:

app_hash = hashlib.md5(app.encode()).hexdigest()

if app_hash in known_malicious_apps:

malicious_apps.append(app)

return malicious_apps

# Function to generate a key for encryption

def generate_key():

return Fernet.generate_key()

# Function to encrypt data

def encrypt_data(data, key):

fernet = Fernet(key)

encrypted_data = fernet.encrypt(data.encode())

return encrypted_data

# Function to decrypt data

def decrypt_data(encrypted_data, key):

fernet = Fernet(key)

decrypted_data = fernet.decrypt(encrypted_data).decode()

return decrypted_data

# Function to monitor network traffic

def monitor_network_traffic():

# Simulating network traffic monitoring (For actual implementation, use libraries like scapy)

print("Monitoring network traffic...")

# Function to establish a secure connection

def secure_connection(host, port):

context = ssl.create_default_context()

with socket.create_connection((host, port)) as sock:

with context.wrap_socket(sock, server_hostname=host) as ssock:

print(ssock.version())

# Function to implement user authentication

def authenticate_user(username, password, stored_hash):

password_hash = hashlib.sha256(password.encode()).hexdigest()
 return password_hash == stored_hash

# Sample usage

if __name__ == "__main__":

# Part 1: Scan for malicious apps

print("=== Part 1: Scan for Malicious Apps ===")

installed_apps = ["app1", "malicious_app"]

malicious_apps_found = scan_for_malicious_apps(installed_apps)

if malicious_apps_found:

print("Malicious apps found:", malicious_apps_found)

else:

print("No malicious apps found.")

# Part 2: Secure data storage

print("\n=== Part 2: Secure Data Storage ===")

key = generate_key()

sensitive_data = "This is a sensitive information"

encrypted_data = encrypt_data(sensitive_data, key)

print("Sensitive data:", sensitive_data)

print("Encrypted data:", encrypted_data)

decrypted_data = decrypt_data(encrypted_data, key)

print("Decrypted data:", decrypted_data)

# Part 3: Monitor network traffic

print("\n=== Part 3: Monitor Network Traffic ===")

monitor_network_traffic()

# Part 4: Establish a secure connection

print("\n=== Part 4: Establish Secure Connection ===")

secure_connection("www.example.com", 443)

# Part 5: User authentication

print("\n=== Part 5: User Authentication ===")

username = input("Enter username: ")

password = getpass("Enter password: ")

stored_hash = hashlib.sha256("secure_password".encode()).hexdigest()
if authenticate_user(username, password, stored_hash):

print("Authentication successful.")

else:

print("Authentication failed.")