1.

Caesar Cipher
def encrypt(text, k):
result = " "
for i in range(len(text)):
char = text[i]
if (char.isupper()):
result += chr((ord(char) + k - 65) % 26 + 65)
else:
result += chr((ord(char) + k - 97) % 26 + 97)
return result

def decrypt(k):
text1 = " "
c=encrypt(text,k)
for i in range(1,len(c)):
char = c[i]
if (char.isupper()):
text1 += chr((ord(char) - k - 65) % 26 + 65)
else:
text1 += chr((ord(char) - k - 97) % 26 + 97)
return text1

text = input("Enter a String which is to be encrypted : ")

k = int(input("Enter a Shift Pattern : "))
print("PLAIN TEXT : ", text)
print("GIVEN KEY IS : ", k)
print("ENCRYPTED TEXT : ", encrypt(text, k))
print("DECRYPTED TEXT : ", decrypt(k))

2. Rail fence Technique

def encrypt(text, key):

rail = [['\n' for i in range(len(text))]
for j in range(key)]
down = False
row, col = 0,0
for i in range(len(text)):
if (row == 0) or (row == key -1):
down = not down
 rail[row][col] = text[i]
col +=1
if down:
row +=1
else:
row -=1
result= []
for i in range(key):
for j in range(len(text)):
if rail[i][j] != '\n':
result.append(rail[i][j])
return("" . join(result))

def decrypt(c,k):
rail = [['\n' for i in range(len(text))]
for j in range(k)]
down = None
row, col = 0,0
c=encrypt(text,k)
for i in range(len(c)):
if row ==0:
down = True
if row == k -1:
down = False
rail[row][col]='*'
col += 1
if down:
row +=1
else:
row -=1
index=0
for i in range(k):
for j in range(len(c)):
if((rail[i][j] == '*') and (index < len(c))):
rail[i][j] = c[index]
 index+=1
result= []
row , col = 0,0
for i in range(len(c)):
if row == 0:
down = True
if row == k-1:
down = False
if (rail[row][col] != '*'):
result.append(rail[row][col])
col += 1
if down:
row +=1
else:
row -=1
return ("".join(result))

text = input("Enter a String which is to be encrypted : ")

k = int(input("Enter a Shift Pattern : "))
print("PLAIN TEXT : ", text)
print("GIVEN KEY IS : ", k)
print("ENCRYPTED TEXT : ", encrypt(text, k))
c= encrypt(text,k)
print("DECRYPTED TEXT : ", decrypt(c,k))

3. Vignere Cipher

def generateKey(string, key):

key = list(key)
if len(string) == len(key):
return(key)
else:
for i in range(len(string) - len(key)):
key.append(key[i % len(key)])
return("" . join(key))

def cipherText(string, key):

 cipher_text = []
for i in range(len(string)):
x = (ord(string[i]) + ord(key[i])) % 26
x += ord('A')
cipher_text.append(chr(x))
return("" . join(cipher_text))

def originalText(cipher_text, key):

orig_text = []
for i in range(len(cipher_text)):
x = (ord(cipher_text[i]) - ord(key[i]) + 26) % 26
x += ord('A')
orig_text.append(chr(x))
return("" . join(orig_text))

m = input("Enter a String which is to be encrypted : ")

k = input("Enter a Shift Pattern : ")
key =generateKey(m,k)
print("PLAIN TEXT : ", m)
print("GIVEN KEY IS : ", k)
print("ENCRYPTED TEXT : ",cipherText(m,key))
c=cipherText(m,key)
print("DECRYPTED TEXT : ",originalText(c,k))

4. Hill Cipher

keyMatrix= [[0] * 3 for i in range(3)]

message = [[0] for i in range(3)]
cipher = [[0] for i in range(3)]
def getKey(key):
k=0
for i in range(3):
for j in range(3):
keyMatrix[i][j] = ord(key[k]) % 65
k += 1
def encrypt(message):
for i in range(3):
for j in range(1):
cipher[i][j] = 0
for x in range(3):
cipher[i][j] += (keyMatrix[i][x] * message[x][j])
cipher[i][j] = cipher[i][j] % 26
def HillCipher(m, key):
 getKey(key)
for i in range(3):
message[i][0] = ord(m[i]) % 65
encrypt(message)
CipherText = []
for i in range(3):
CipherText.append(chr(cipher[i][0] + 65))
print("Ciphertext: ", "".join(CipherText))

m = input("Enter a String which is to be encrypted : ")

k = input("Enter a Shift Pattern : ")
print("PLAIN TEXT : ", m)
print("GIVEN KEY IS : ", k)
HillCipher(m,k)

5. Playfair cipher

def toLowerCase(text):
return text.lower()
def removeSpaces(text):
newText = ""
for i in text:
if i == " ":
continue
else:
newText = newText + i
return newText
def Diagraph(text):
Diagraph = []
group = 0
for i in range(2, len(text), 2):
Diagraph.append(text[group:i])

group = i
Diagraph.append(text[group:])
return Diagraph
def FillerLetter(text):
k = len(text)
if k % 2 == 0:
for i in range(0, k, 2):
if text[i] == text[i+1]:
new_word = text[0:i+1] + str('x') + text[i+1:]
new_word = FillerLetter(new_word)
 break
else:
new_word = text
else:
for i in range(0, k-1, 2):
if text[i] == text[i+1]:
new_word = text[0:i+1] + str('x') + text[i+1:]
new_word = FillerLetter(new_word)
break
else:
new_word = text
return new_word
list1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
def generateKeyTable(word, list1):
key_letters = []
for i in word:
if i not in key_letters:
key_letters.append(i)
compElements = []
for i in key_letters:
if i not in compElements:
compElements.append(i)
for i in list1:
if i not in compElements:
compElements.append(i)
matrix = []
while compElements != []:
matrix.append(compElements[:5])
compElements = compElements[5:]
return matrix
def search(mat, element):
for i in range(5):
for j in range(5):
if(mat[i][j] == element):
return i, j
def encrypt_RowRule(matr, e1r, e1c, e2r, e2c):
char1 = ''
if e1c == 4:
char1 = matr[e1r][0]
else:
char1 = matr[e1r][e1c+1]
char2 = ''
if e2c == 4:
 char2 = matr[e2r][0]
else:
char2 = matr[e2r][e2c+1]

return char1, char2

def encrypt_ColumnRule(matr, e1r, e1c, e2r, e2c):
char1 = ''
if e1r == 4:
char1 = matr[0][e1c]
else:
char1 = matr[e1r+1][e1c]
char2 = ''
if e2r == 4:
char2 = matr[0][e2c]
else:
char2 = matr[e2r+1][e2c]
return char1, char2
def encrypt_RectangleRule(matr, e1r, e1c, e2r, e2c):
char1 = ''
char1 = matr[e1r][e2c]
char2 = ''
char2 = matr[e2r][e1c]

return char1, char2

def encryptByPlayfairCipher(Matrix, plainList):
CipherText = []
for i in range(0, len(plainList)):
c1 = 0
c2 = 0
ele1_x, ele1_y = search(Matrix, plainList[i][0])
ele2_x, ele2_y = search(Matrix, plainList[i][1])
if ele1_x == ele2_x:
c1, c2 = encrypt_RowRule(Matrix, ele1_x, ele1_y, ele2_x, ele2_y)
elif ele1_y == ele2_y:
c1, c2 = encrypt_ColumnRule(Matrix, ele1_x, ele1_y, ele2_x, ele2_y)
else:
c1, c2 = encrypt_RectangleRule(
Matrix, ele1_x, ele1_y, ele2_x, ele2_y)
cipher = c1 + c2
CipherText.append(cipher)
return CipherText

m = input("Enter a String which is to be encrypted : ")

text_Plain = removeSpaces(toLowerCase(m))
PlainTextList = Diagraph(FillerLetter(text_Plain))
if len(PlainTextList[-1]) != 2:
PlainTextList[-1] = PlainTextList[-1]+'z'

k = input("Enter a Shift Pattern : ")

k = toLowerCase(k)
print("PLAIN TEXT : ", m)
print("GIVEN KEY IS : ", k)
Matrix = generateKeyTable(k, list1)
CipherList = encryptByPlayfairCipher(Matrix, PlainTextList)
CipherText = ""
for i in CipherList:
CipherText += i
print("CipherText:", CipherText)

MD5 Algorithm

import hashlib
inp = "Hello"
out1 = hashlib.md5(inp.encode())
print(out1.hexdigest())

Sha-1 Algorithm

import hashlib
inp = "Hello"
out1 = hashlib.sha1(inp.encode())
print(out1.hexdigest())

RSA and Diffie Hellman

import math
import random
from random import randint
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
def mod_inverse(a, m):
for x in range(1, m):
if (a * x) % m == 1:
return x
 return -1
def isPrime(n):
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
# print('The number entered wasn\'t a prime number')
return False
return True
if __name__ == '__main__':
choice = 0
P = int(input('Enter a prime number: '))
while not isPrime(P):
P = int(input('Enter a prime number: '))
# Primitive Root
G=2
flag = True
def primitive_root(P, G):
lst = []
flag = False
for k in range(1, P):
res = math.fmod(pow(G, k), P)
if res in lst:
flag = True
lst.append(res)
return flag
while flag is True:
G += 1
flag = primitive_root(P, G)
print('Primitive Root:', G)
a = int(input('Enter a private key for A: '))
# Generated Key
x = int(pow(G, a, P))
b = int(input('Enter a private key for B: '))
# Generated Key
y = int(pow(G, b, P))
# Secret key for A
# ka = y^a mod p
ka = int(pow(y, a, P))
# Secret key for B
# kb = x^b mod p
kb = int(pow(x, b, P))
print('Secret key for A is :', ka)
print('Secret Key for B is :', kb)
# P - 23 A - 3 B - 5
P = ka
while not isPrime(P):
P += 1
Q=P+1
while not isPrime(Q):
Q += 1
print('P value is', P)
print('Q value is', Q)
print()
e=2
phi = (P - 1) * (Q - 1)
while (e < phi):
if (gcd(e, phi) == 1):
break
else:
e=e+1
n=P*Q
while True:
g = gcd(e, phi)
# Generate private key
d = mod_inverse(e, phi)
if g == 1 and e != d:
break
while True:
msg_plaintext = input('Enter plain text message: ')
msg_ciphertext = [pow(ord(c), e, n) for c in msg_plaintext]
print('Encrypted Message: ', msg_ciphertext)
msg_plaintext = [chr(pow(int(c), d, n)) for c in msg_ciphertext]
print('Original Message: ', (''.join(msg_plaintext)))
break