# SHA-256 Hashing
import hashlib
# Function to hash a string using SHA-256
def sha256_hash_string(input_string):
# Create a new sha256 hash object
sha256 = hashlib.sha256()
# Update the hash object with the bytes of the input string
sha256.update(input_string.encode('utf-8'))
# Get the hexadecimal representation of the hash
hex_digest = sha256.hexdigest()
return hex_digest
# Example usage
input_string = "Hello, world!"
hash_result = sha256_hash_string(input_string)
print(f"SHA-256 hash of '{input_string}': {hash_result}")
#RSA
import math
# step 1
p = 3
q = 7
# step 2
n = p*q
print("n =", n)
# step 3
phi = (p-1)*(q-1)
# step 4
e = 2
while(e<phi):
if (math.gcd(e, phi) == 1):
break
else:
e += 1
print("e =", e)
# step 5
k = 2
d = ((k*phi)+1)/e
print("d =", d)
print(f'Public key: {e, n}')
print(f'Private key: {d, n}')
# plain text
msg = 11
print(f'Original message:{msg}')
# encryption
C = pow(msg, e)
C = math.fmod(C, n)
print(f'Encrypted message: {C}')
# decryption
M = pow(C, d)
M = math.fmod(M, n)
print(f'Decrypted message: {M}')
#Vernam
def Vernam(text, key):
cipher_text = ''
for i in range(len(text)):
character = chr(ord(text[i]) ^ ord(key[i]))
cipher_text += character
return cipher_text
if __name__ == "__main__":
text = "My Secret text"
key = 'mjcipuqszsymzp' # Ensure key is at least as long as text
cipher_text = Vernam(text, key)
print("Cipher text:", repr(cipher_text))
original_text = Vernam(cipher_text, key)
print("Original text:", original_text)
#Vignere
def vigenere(text, key, mode='encrypt'):
key = (key * (len(text) // len(key) + 1))[:len(text)]
res = []
for t, k in zip(text, key):
if mode == 'encrypt':
res.append(chr((ord(t) + ord(k) - 2 * ord('A')) % 26 + ord('A')))
else:
res.append(chr((ord(t) - ord(k) + 26) % 26 + ord('A')))
return ''.join(res)
if __name__ == "__main__":
text = "HELLOVIGENERECIPHER"
key = "KEY"
cipher_text = vigenere(text, key, mode='encrypt')
print("Cipher Text: ", cipher_text)
original_text = vigenere(cipher_text, key, mode='decrypt')
print("Original Text: ", original_text)
#rc4
def rc4(key, data):
S = list(range(256))
j = 0
out = []
# Key scheduling algorithm (KSA)
for i in range(256):
j = (j + S[i] + key[i % len(key)]) % 256
S[i], S[j] = S[j], S[i]
# Pseudo-random generation algorithm (PRGA)
i = j = 0
for char in data:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
out.append(char ^ S[(S[i] + S[j]) % 256])
return bytes(out)
# Main program
if __name__ == "__main__
":
key = b'secretkey' # Key for encryption/decryption
plain_text = "This is a secret message."
# Convert plaintext to bytes
plain_text_bytes = plain_text.encode('utf-8')
# Encrypt
encrypted = rc4(key, plain_text_bytes)
print(f"Encrypted text: {encrypted}")
# Decrypt (RC4 encryption and decryption are symmetric)
decrypted = rc4(key, encrypted)
print(f"Decrypted text: {decrypted.decode('utf-8')}")
#hill cipher
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))
def main():
message = "ACT"
key = "GYBNQKURP"
HillCipher(message, key)
if __name__ == "__main__":
main()
#feistel
def xor_strings(s1, s2):
return ''.join(chr(ord(a) ^ ord(b)) for a, b in zip(s1, s2))
def feistel_round(left, right, key):
new_left = right
new_right = xor_strings(left, xor_strings(right, key))
return new_left, new_right
def feistel(text, keys, encrypt=True):
left, right = text[:len(text)//2], text[len(text)//2:]
if not encrypt:
keys = reversed(keys)
for key in keys:
left, right = feistel_round(left, right, key)
return left + right
if __name__ == "__main__":
text = "HELLO123" # Text length should be even
keys = ["K1", "K2", "K3", "K4"] # Example round keys
# Ensure text length is even
if len(text) % 2 != 0:
text += "X"
encrypted_text = feistel(text, keys, encrypt=True)
print("Encrypted Text:", encrypted_text)
decrypted_text = feistel(encrypted_text, keys, encrypt=False)
print("Decrypted Text:", decrypted_text)
#aes
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
def aes_encrypt(plaintext, key):
cipher = AES.new(key, AES.MODE_CBC)
ciphertext = cipher.encrypt(pad(plaintext.encode('utf-8'), AES.block_size))
return cipher.iv + ciphertext
def aes_decrypt(ciphertext, key):
iv = ciphertext[:AES.block_size]
cipher = AES.new(key, AES.MODE_CBC, iv)
plaintext = unpad(cipher.decrypt(ciphertext[AES.block_size:]), AES.block_size)
return plaintext.decode('utf-8')
if __name__ == "__main__":
plaintext = "Hello, AES!"
key = get_random_bytes(16) # AES-128 key (16 bytes)
ciphertext = aes_encrypt(plaintext, key)
print("Ciphertext:", ciphertext)
decrypted_text = aes_decrypt(ciphertext, key)
print("Decrypted Text:", decrypted_text)
#2 des
from Crypto.Cipher import DES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
def des_encrypt(plaintext, key):
cipher = DES.new(key, DES.MODE_ECB)
return cipher.encrypt(plaintext)
def des_decrypt(ciphertext, key):
cipher = DES.new(key, DES.MODE_ECB)
return cipher.decrypt(ciphertext)
def double_des_encrypt(plaintext, key1, key2):
padded_plaintext = pad(plaintext, DES.block_size)
encrypted = des_encrypt(padded_plaintext, key1)
encrypted = des_encrypt(encrypted, key2)
return encrypted
def double_des_decrypt(ciphertext, key1, key2):
decrypted = des_decrypt(ciphertext, key2)
decrypted = des_decrypt(decrypted, key1)
return unpad(decrypted, DES.block_size)
if __name__ == "__main__":
plaintext = b"Hello, 2DES!" # Example plaintext (as bytes)
key1 = get_random_bytes(8) # First DES key (8 bytes)
key2 = get_random_bytes(8) # Second DES key (8 bytes)
ciphertext = double_des_encrypt(plaintext, key1, key2)
print("Ciphertext:", ciphertext)
decrypted_text = double_des_decrypt(ciphertext, key1, key2)
print("Decrypted Text:", decrypted_text.decode('utf-8'))
#ceaser
def encrypt(text, shift):
result = ""
# traverse text
for i in range(len(text)):
char = text[i]
# Encrypt uppercase characters
if char.isupper():
result += chr((ord(char) + shift - 65) % 26 + 65)
# Encrypt lowercase characters
elif char.islower():
result += chr((ord(char) + shift - 97) % 26 + 97)
# Encrypt digits
elif char.isdigit():
result += chr((ord(char) + shift - 48) % 10 + 48)
# Encrypt special characters
else:
result += char
return result
def decrypt(text, shift):
return encrypt(text, -shift)
# Example usage
text = "Hello, World! 123"
shift = 4
encrypted = encrypt(text, shift)
decrypted = decrypt(encrypted, shift)
print(f"Text: {text}")
print(f"Shift: {shift}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")
