Merge pull request #2063 from hima-v/cryptography-algorithms

Cryptography Algorithms to encrypt and decrypt

Author: avinashkranjan

Cryptography/Algorithms/Caesar-cipher.py

@@ -0,0 +1,47 @@
+# For caeser cipher the key size is fixed as: key = 3
+
+import string
+
+key = 3
+# store all the alphabets in upper and lowercase in a String variable
+all_letters = string.ascii_letters
+
+# taking inputs
+plain_txt = input("Enter the text you want to Encrypt: \n")
+cipher_txt = []
+
+# create a dictionary which maps the alphabets with respective substitution as per key size
+dict1 = {}
+for i in range(len(all_letters)):
+    dict1[all_letters[i]] = all_letters[(i + key) % len(all_letters)]
+
+# iterate through the plaintext characters and do necessary substittion
+for char in plain_txt:
+    if char in all_letters:
+        temp = dict1[char]
+        cipher_txt.append(temp)
+    else:
+        temp = char
+        cipher_txt.append(temp)
+
+# concatenate all the list elements
+cipher_txt = "".join(cipher_txt)
+
+# create a dictionary for reverse mapping
+dict2 = {}
+for i in range(len(all_letters)):
+    dict2[all_letters[i]] = all_letters[(i - key) % (len(all_letters))]
+decrypt_txt = []
+
+for char in cipher_txt:
+    if char in all_letters:
+        temp = dict2[char]
+        decrypt_txt.append(temp)
+    else:
+        temp = char
+        decrypt_txt.append(temp)
+decrypt_txt = "".join(decrypt_txt)
+
+# display the Cipher Text and Recovered Plain Text
+print("\nCipher Text is: ", cipher_txt)
+print("Recovered plain text: ", decrypt_txt)

Cryptography/Algorithms/Diffie-Hellman.py

@@ -0,0 +1,33 @@
+n = int(input("prime no: \n"))
+g = int(input("prime no: \n"))
+x = 3
+y = 6
+
+
+def al():
+    A = (g**x) % n
+    return A
+
+
+def bob():
+    B = (g**y) % n
+    return B
+
+
+def akey():
+    Bval = bob()
+    k1 = (Bval**x) % n
+    return k1
+
+
+def bkey():
+    Aval = al()
+    k2 = (Aval**y) % n
+    return k2
+
+
+if akey() == bkey():
+    print("shared symmetric key")
+    print(akey(), bkey())
+else:
+    print("error")

Cryptography/Algorithms/README.md

@@ -0,0 +1,13 @@
+# Cryptography Algorithms
+
+# Description
+Its a collection of different cryptography algorithms used for encryption and key exchange protocols.
+Following are the list of algorithms:
+1. Ceaser Cipher
+2. Diffie Hellman Key Exchange Protocol
+3. RSA Encryption and Decryption
+4. Substitution Cipher
+
+# Getting Started
+1. Run the programs locally
+2. Input the parameters such as key size and plain text when prompted

Cryptography/Algorithms/RSA.py

@@ -0,0 +1,70 @@
+import math
+import random
+
+
+# Arguments provide range to generate two prime numbers
+def primenumbers(srt, n):
+    primenos = []
+    prime = [True for i in range(n + 2 - srt)]
+    prime[0] = False
+    prime[1] = False
+    for p in range(srt, int(math.sqrt(n)) + 1):
+        if prime[p] == True:
+            for i in range(p * p, n + 1, p):
+                prime[i] = False
+    for p in range(srt, n + 1):
+        if prime[p]:
+            primenos.append(p)
+    P = random.choice(primenos)
+    primenos.remove(P)
+    Q = random.choice(primenos)
+    return (P, Q)
+
+
+# RSA Algorithm Implementation:
+print("RSA Implementation starts for the connection")
+for c in range(5):
+    print("------")
+
+p, q = primenumbers(1, 30)
+N = p * q
+f = (p - 1) * (q - 1)
+
+
+# Generate Public Key for Encryption
+def publickey():
+    for i in range(2, f):
+        if math.gcd(f, i) == 1:
+            E = i
+            break
+    return E
+
+
+E = publickey()
+
+
+def privatekey():
+    for j in range(1, N):
+        if math.fmod((E * j), (f)) == 1:
+            # if (E * j) % (f) == 1:
+            D = j
+            break
+    return D
+
+
+D = privatekey()
+print("Generated Public Key for Encryption E: ", E)
+print("Generated Private Key for Decryption D: ", D)
+Plain_text = float(input("Enter Plain text in numerical data type: \n"))
+
+x = math.pow(Plain_text, E)
+Cipher_text = math.fmod(x, N)
+print("Generated Cipher Text using Public Key: ", Cipher_text)
+
+D_user = int(input("Enter your private key for Decryption \n"))
+if D_user == D:
+    y = math.pow(Cipher_text, D)
+    Decrypted_text = math.fmod(y, N)
+    print("The Cipher Text has been decrypted: ", Plain_text)
+else:
+    print("ENTERED WRONG PRIVATE KEY")

Cryptography/Algorithms/Substitution-cipher.py

@@ -0,0 +1,45 @@
+import string
+
+# store all the alphabets in upper and lowercase in a String variable
+all_letters = string.ascii_letters
+
+# taking inputs
+key = int(input("Enter the key value in integer: \n"))
+plain_txt = input("Enter the text you want to Encrypt: \n")
+cipher_txt = []
+
+# create a dictionary which maps the alphabets with respective substitution as per key size
+dict1 = {}
+for i in range(len(all_letters)):
+    dict1[all_letters[i]] = all_letters[(i + key) % len(all_letters)]
+
+# iterate through the plaintext characters and do necessary substittion
+for char in plain_txt:
+    if char in all_letters:
+        temp = dict1[char]
+        cipher_txt.append(temp)
+    else:
+        temp = char
+        cipher_txt.append(temp)
+
+# concatenate all the list elements
+cipher_txt = "".join(cipher_txt)
+
+# create a dictionary for reverse mapping
+dict2 = {}
+for i in range(len(all_letters)):
+    dict2[all_letters[i]] = all_letters[(i - key) % (len(all_letters))]
+decrypt_txt = []
+
+for char in cipher_txt:
+    if char in all_letters:
+        temp = dict2[char]
+        decrypt_txt.append(temp)
+    else:
+        temp = char
+        decrypt_txt.append(temp)
+decrypt_txt = "".join(decrypt_txt)
+
+# display the Cipher Text and Recovered Plain Text
+print("\nCipher Text is: ", cipher_txt)
+print("Recovered plain text: ", decrypt_txt)