Asmit 2820425
Panipat Institute of Engineering & Technology
Samalkha
Computer Science & Engineering Department
12
Practical File of Cryptanalysis
Code - PC-CS-CYS-316LA
Submitted to: Mrs. Pooja Sharma Submitted by: Asmit
Assistant Professor 2820411
CSE Department CSE 3rd YearET-Cyber
Section-F
Affiliated to:
Asmit 2820425
Serial Experiments Date Signature
Number
1. Write a program to perform
encryption and decryption 3 using the
following algorithms: a) Ceaser
Cipher b) Substitution Cipher c) Hill
Cipher
2. Implementation of various Stream
Ciphers, such as, additive cipher,
multiplicative cipher, and affine
cipher with cryptanalysis.
3. Write a program to implement the
DES and AES algorithm logic.
4. Implementation of Euclidean’s
algorithm, Chinese reminder theorem,
Primality test, Fermat’s algorithms,
Euler algorithm.
5. Write a program to implement the
Blowfish algorithm.
6. Using Cryptography, encrypt the text
“Hello world” using Blow Fish.
7. Create your own key using Java key
tool.
8. Write a program to implement RSA
Algorithm.
9. Implement the Diffie Hellman Key
Exchange mechanism using HTML
and JavaScript.
10. Configure SSH (Secure Shell) and
send/receive a file on this connection to
verify the I correctness of this system
using the configured parameters.
-2-
Asmit 2820425
EXPERIMENT-1
Aim: Write a program to perform encryption and decryption 3 using the following
algorithms: a) Ceaser Cipher b) Substitution Cipher c) Hill Cipher
Code:
(a) Ceaser cipher
(Encryption)
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
text = "ATTACKATONCE"
s=4
print ("Text : " + text)
print ("Shift : " + str(s))
print ("Cipher: " + encrypt(text,s))
OUTPUT :
-3-
Asmit 2820425
(Decryption)
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
text = "0123456789"
s=4
Cipher=encrypt(text,s)
print("Text : " + text)
print ("Shift : " + str(s))
print ("Cipher: " + encrypt(text,s))
OUTPUT:
-4-
Asmit 2820425
(b) Substitution Cipher
(Encryption) and (Decryption)
import random
alphabet = 'abcdefghijklmnopqrstuvwxyz.,! '
key = 'nu.t!iyvxqfl,bcjrodhkaew spzgm'
plaintext = "Hey, this is really fun!"
def makeKey(alphabet):
alphabet = list(alphabet)
random.shuffle(alphabet)
return ''.join(alphabet)
def encrypt(plaintext, key, alphabet):
keyIndices = [alphabet.index(k.lower()) for k in plaintext]
return ''.join(key[keyIndex] for keyIndex in keyIndices)
def decrypt(cipher, key, alphabet):
keyIndices = [key.index(k) for k in cipher]
return ''.join(alphabet[keyIndex] for keyIndex in keyIndices)
cipher = encrypt(plaintext, key, alphabet)
print(plaintext)
print(cipher)
print(decrypt(cipher, key, alphabet))
OUTPUT:
-5-
Asmit 2820425
( c ) Hill Cipher
(Encryption)
keyMatrix = [[0] * 3 for i in range(3)]
messageVector = [[0] for i in range(3)]
cipherMatrix = [[0] for i in range(3)]
def getKeyMatrix(key):
k=0
for i in range(3):
for j in range(3):
keyMatrix[i][j] = ord(key[k]) % 65
k += 1
def encrypt(messageVector):
for i in range(3):
for j in range(1):
cipherMatrix[i][j] = 0
for x in range(3):
cipherMatrix[i][j] += (keyMatrix[i][x] *
messageVector[x][j])
cipherMatrix[i][j] = cipherMatrix[i][j] % 26
def HillCipher(message, key):
getKeyMatrix(key)
for i in range(3):
messageVector[i][0] = ord(message[i]) % 65
encrypt(messageVector)
CipherText = []
for i in range(3):
CipherText.append(chr(cipherMatrix[i][0] + 65))
print("Ciphertext: ", "".join(CipherText))
-6-
Asmit 2820425
def main():
message = "ACT"
key = "GYBNQKURP"
HillCipher(message, key)
if name == " main ":
main()
OUTPUT:
-7-
Asmit 2820425
EXPERIMENT – 2
Aim: Implementation of various Stream Ciphers, such as, additive cipher, multiplicative
cipher, and affine cipher with cryptanalysis.
Code:
(Additive Cipher)
plain = input("Enter your plaintext: ")
key = int(input("Enter your cipher key: "))
encrypted = ""
for char in plain:
if char.isalpha():
shifted = (ord(char) - 97 + key) % 26 + 97
encrypted += chr(shifted)
else:
encrypted += char
print(encrypted)
OUTPUT:
(Multiplicative Cipher)
plain = input("Enter your plaintext: ")
key = int(input("Enter your cipher key: "))
encrypted = ""
for char in plain:
if char.isalpha():
shifted = ((ord(char) - 97) * key) % 26 + 97
encrypted += chr(shifted)
else:
encrypted += char
print(encrypted)
-8-
Asmit 2820425
OUTPUT:
(Affine Cipher)
plain = input("Enter your plaintext: ")
a = int(input("Enter the first key (must be coprime with 26): "))
b = int(input("Enter the second key: "))
alphabet = "abcdefghijklmnopqrstuvwxyz"
for i in range(2, 26):
if (a * i) % 26 == 1:
break
else:
print("Error: a is not coprime with 26.")
exit()
encrypted = ""
for char in plain:
if char.isalpha():
index = alphabet.index(char)
shifted = (a * index + b) % 26
encrypted += alphabet[shifted]
else:
encrypted += char
print(encrypted)
OUTPUT:
-9-
Asmit 2820425
EXPERIMENT – 3
Aim: Write a program to implement the DES and AES algorithm logic.
Code:
1. (DES)
# Hexadecimal to binary conversion for Des.
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
# Binary to hexadecimal conversion
def bin2hex(s):
mp = {"0000": '0',
"0001": '1',
"0010": '2',
"0011": '3',
"0100": '4',
"0101": '5',
- 10
Asmit 2820425
"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
# Binary to decimal conversion
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
# Decimal to binary conversion
def dec2bin(num):
res = bin(num).replace("0b", "")
if(len(res) % 4 != 0):
div = len(res) / 4
div = int(div)
- 11
Asmit 2820425
counter = (4 * (div + 1)) - len(res)
for i in range(0, counter):
res = '0' + res
return res
# Permute function to rearrange the bits
def permute(k, arr, n):
permutation = ""
for i in range(0, n):
permutation = permutation + k[arr[i] - 1]
return permutation
# shifting the bits towards left by nth shifts
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
# calculating xow of two strings of binary number a and b
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
# Table of Position of 64 bits at initial level: Initial Permutation Table
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,
- 12
Asmit 2820425
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]
# Expansion D-box Table
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]
# Straight Permutation Table
per = [16, 7, 20, 21,
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]
# S-box Table
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
Asmit 2820425
[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],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[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 Permutation Table
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)
# Initial Permutation
pt = permute(pt, initial_perm, 64)
print("After initial permutation", bin2hex(pt))
- 14
Asmit 2820425
# Splitting
left = pt[0:32]
right = pt[32:64]
for i in range(0, 16):
# Expansion D-box: Expanding the 32 bits data into 48 bits
right_expanded = permute(right, exp_d, 48)
# XOR RoundKey[i] and right_expanded
xor_x = xor(right_expanded, rkb[i])
# S-boxex: substituting the value from s-box table by calculating row and
column
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)
# Straight D-box: After substituting rearranging the bits
sbox_str = permute(sbox_str, per, 32)
# XOR left and sbox_str
result = xor(left, sbox_str)
left = result
# Swapper
if(i != 15):
left, right = right, left
print("Round ", i + 1, " ", bin2hex(left),
" ", bin2hex(right), " ", rk[i])
# Combination
combine = left + right
# Final permutation: final rearranging of bits to get cipher text
cipher_text = permute(combine, final_perm, 64)
return cipher_text
- 15
Asmit 2820425
pt = "123456ABCD132536"
key = "AABB09182736CCDD"
# Key generation
# --hex to binary
key = hex2bin(key)
# --parity bit drop table
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]
# getting 56 bit key from 64 bit using the parity bits
key = permute(key, keyp, 56)
# Number of bit shifts
shift_table = [1, 1, 2, 2,
2, 2, 2, 2,
1, 2, 2, 2,
2, 2, 2, 1]
# Key- Compression Table : Compression of key from 56 bits to 48 bits
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]
# Splitting
left = key[0:28] # rkb for RoundKeys in binary
right = key[28:56] # rk for RoundKeys in hexadecimal
- 16
Asmit 2820425
rkb = []
rk = []
for i in range(0, 16):
# Shifting the bits by nth shifts by checking from shift table
left = shift_left(left, shift_table[i])
right = shift_left(right, shift_table[i])
# Combination of left and right string
combine_str = left + right
# Compression of key from 56 to 48 bits
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)
- 17
Asmit 2820425
OUTPUT :
(For encryption)
(For decryption)
- 18
Asmit 2820425
2. (AES)
from Crypto.Cipher import AES
key = b'C&F)H@McQfTjWnZr'
cipher = AES.new(key, AES.MODE_EAX)
data = "Welcome to user Coding ".encode()
nonce = cipher.nonce
ciphertext = cipher.encrypt(data)
print("Cipher text:", ciphertext)
print("Cipher text:", ciphertext)
cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
plaintext = cipher.decrypt(ciphertext)
print("Plain text:", plaintext)
OUTPUT:
- 19
Asmit 2820425
EXPERIMENT-4
Aim: Implementation of Euclidean’s algorithm, Chinese reminder theorem, Primality test,
Fermat’s algorithms, Euler algorithm.
Code:
(Euclidean’s Algorithm)
def gcd(a, b):
if a == 0 :
return b
return gcd(b%a, a)
a = 11
b = 15
print("gcd of ", a , "&" , b, " is = ", gcd(a, b))
OUTPUT:
(Chinese Remainder Theorem)
def inv(a, m) :
m0 = m
x0 = 0
x1 = 1
if (m == 1) :
return 0
- 20
2
while (a > 1) :
q = a // m
t=m
m=a%m
a=t
t = x0
x0 = x1 - q * x0
x1 = t
if (x1 < 0) :
x1 = x1 + m0
return x1
def findMinX(num, rem, k) :
prod = 1
for i in range(0, k) :
prod = prod * num[i]
result = 0
for i in range(0,k):
pp = prod // num[i]
result = result + rem[i] * inv(pp, num[i]) * pp
OUTPUT:
- 21
CFGHZ
2820425
(Primality Test)
import random
def modulo(base, exponent, mod):
x = 1;
y = base;
while (exponent > 0):
if (exponent % 2 == 1):
x = (x * y) % mod;
y = (y * y) % mod;
exponent = exponent // 2;
return x % mod;
def calculateJacobian(a, n):
if (a == 0):
return 0;
ans = 1;
if (a < 0):
a = -a;
if (n % 4 == 3):
ans = -ans;
if (a == 1):
return ans;
while (a):
if (a < 0):
- 22
Asmit 2820425
a = -a;
if (n % 4 == 3):
ans = -ans;
while (a % 2 == 0):
a = a // 2;
if (n % 8 == 3 or n % 8 == 5):
ans = -ans;
a, n = n, a;
if (a % 4 == 3 and n % 4 == 3):
ans = -ans;
a = a % n;
if (a > n // 2):
a = a - n;
if (n == 1):
return ans;
return 0;
def solovoyStrassen(p, iterations):
if (p < 2):
return False;
if (p != 2 and p % 2 == 0):
return False;
for i in range(iterations):
a = random.randrange(p - 1) + 1;
jacobian = (p + calculateJacobian(a, p)) % p;
mod = modulo(a, (p - 1) / 2, p);
if (jacobian == 0 or mod != jacobian):
return False;
return True;
- 23
Asmit 2820425
iterations = 50;
num1 = 16;
num2 = 19;
if (solovoyStrassen(num1, iterations)):
print(num1, "is prime ");
else:
print(num1, "is composite");
if (solovoyStrassen(num2, iterations)):
print(num2, "is prime");
else:
print(num2, "is composite");
OUTPUT:
(Fermat Algorithm)
def gcd(a, b):
if(b == 0):
return a
else:
return gcd(b, a % b)
def power(x, y, m):
if (y == 0):
return 1
p = power(x, y // 2, m) % m
p = (p * p) % m
return p if(y % 2 == 0) else (x * p) % m
def modInverse(a, m):
if ( gcd(a, m) != 1):
print("Inverse doesn't exist")
- 24
Asmit 2820425
else:
print("Modular multiplicative inverse is ",
power(a, m - 2, m))
a=5
m = 13
modInverse(a, m)
OUTPUT:
(Euler Algorithm)
def f(x,y):
return x+y
def euler(x0,y0,xn,n):
h = (xn-x0)/n
print('\n-----------SOLUTION ----------- ')
print(' ')
print('x0\ty0\tslope\tyn')
print(' ')
for i in range(n):
slope = f(x0, y0)
yn = y0 + h * slope
print('%.4f\t%.4f\t%0.4f\t%.4f'% (x0,y0,slope,yn) )
print(' ')
y0 = yn
x0 = x0+h
print('\nAt x=%.4f, y=%.4f' %(xn,yn))
print('Enter initial conditions:')
x0 = float(input('x0 = '))
y0 = float(input('y0 = '))
print('Enter calculation point: ')
- 25
Asmit 2820425
xn = float(input('xn = '))
print('Enter number of steps:')
step = int(input('Number of steps = '))
euler(x0,y0,xn,step)
OUTPUT:
- 26
Asmit 282045
EXPERIMENT-5
Aim :- Write a program to implement the Blowfish algorithm.
Code:-
from Crypto.Cipher import Blowfish
from Crypto import Random
from struct import pack
bs = Blowfish.block_size
key = b'An arbitrarily long key'
iv = Random.new().read(bs)
cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
plaintext = b'poojasharma'
plen = bs - divmod(len(plaintext),bs)[1]
padding = [plen]*plen
padding = pack('b'*plen, *padding)
msg = iv + cipher.encrypt(plaintext + padding)
print("The encrypted message is: ", msg)
- 27
Asmit 282045
OUTPUT:
- 28
Asmit 282045
EXPERIMENT – 6
Aim: Using Cryptography, encrypt the text “Hello world” using Blow Fish.
Code:-
from Crypto.Cipher import Blowfish
from Crypto import Random
from struct import pack
bs = Blowfish.block_size
key = b'An arbitrarily long key'
iv = Random.new().read(bs)
cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
plaintext = b'hello world'
plen = bs - divmod(len(plaintext),bs)[1]
padding = [plen]*plen
padding = pack('b'*plen, *padding)
msg = iv + cipher.encrypt(plaintext + padding)
print("The encrypted message is: ", msg)
OUTPUT:
- 29
Asmit 2820425
EXPERIMENT – 7
Aim: Implementation of MD5.
Code:-
import hashlib
result = hashlib.md5(b’abcd')
print("The byte equivalent of hash is : ", end ="")
print(result.digest())
OUTPUT:
- 30
Asmit 2820425
EXPERIMENT – 8
Aim: Write a program to implement RSA Algorithm.
Code:-
import math
p=3
q=7
n = p*q
print("n =", n)
phi = (p-1)*(q-1)
e=2
while(e<phi):
if (math.gcd(e, phi) == 1):
break
else:
e += 1
print("e =", e)
k=2
- 31
Asmit 2820425
d = ((k*phi)+1)/e
print("d =", d)
print(f'Public key: {e, n}')
print(f'Private key: {d, n}')
msg = 11
print(f'Original message:{msg}')
C = pow(msg, e)
C = math.fmod(C, n)
print(f'Encrypted message: {C}')
M = pow(C, d)
M = math.fmod(M, n)
print(f'Decrypted message: {M}')
OUTPUT:
- 32
Asmit 2820425
EXPERIMENT – 9
Aim: Implementation of SHA – 1.
Code:-
import hashlib
str = "www.MyABCDEFS.com"
encoded_str = str.encode()
hash_obj = hashlib.sha1(encoded_str)
hexa_value = hash_obj.hexdigest()
print("\n", hexa_value, "\n")
OUTPUT:
- 33
Asmit
EXPERIMENT-10
Aim: Create your own key with Diffie Hellman Key exchange mechanism.
Code:
def prime_checker(p):
if p < 1:
return -1
elif p > 1:
if p == 2:
return 1
for i in range(2, p):
if p % i == 0:
return -1
return 1
def primitive_check(g, p, L):
for i in range(1, p):
L.append(pow(g, i) % p)
for i in range(1, p):
if L.count(i) > 1:
L.clear()
return -1
return 1
l = []
while 1:
P = int(input("Enter P : "))
if prime_checker(P) == -1:
print("Number Is Not Prime, Please Enter Again!")
continue
break
while 1:
G = int(input(f"Enter The Primitive Root Of {P} : "))
if primitive_check(G, P, l) == -1:
print(f"Number Is Not A Primitive Root Of {P}, Please Try Again!")
continue
- 34
Asmit 2820425
break
x1, x2 = int(input("Enter The Private Key Of User 1 : ")), int(
input("Enter The Private Key Of User 2 : "))
while 1:
if x1 >= P or x2 >= P:
print(f"Private Key Of Both The Users Should Be Less Than {P}!")
continue
break
y1, y2 = pow(G, x1) % P, pow(G, x2) % P
k1, k2 = pow(y2, x1) % P, pow(y1, x2) % P
print(f"\nSecret Key For User 1 Is {k1}\nSecret Key For User 2 Is {k2}\n")
if k1 == k2:
print("Keys Have Been Exchanged Successfully")
else:
print("Keys Have Not Been Exchanged Successfully")
OUTPUT:
- 35
Asmit 2820425
- 36
