HILL CIPHER:
import java.util.Scanner;
public class EncryptionDecryption {
public static void main(String[] args) {
// a[][] denotes encryption key K
// b[][] denotes K inverse
int[][] a = {{17, 17, 5}, {21, 18, 21}, {2, 2, 19}};
int[][] b = {{4, 9, 15}, {15, 17, 6}, {24, 0, 17}};
int[] c = new int[20];
int[] d = new int[20];
char[] msg;
Scanner scanner = new Scanner(System.in);
System.out.print("Enter plain text: ");
msg = scanner.nextLine().toUpperCase().toCharArray();
int n = msg.length;
for (int i = 0; i < n; i++) {
c[i] = msg[i] - 65;
System.out.print(c[i] + " ");
}
for (int i = 0; i < 3; i++) {
int t = 0;
for (int j = 0; j < 3; j++) {
t = t + (c[j] * a[j][i]);
}
d[i] = t % 26;
}
System.out.print("\nEncrypted Cipher Text: ");
for (int i = 0; i < 3; i++)
System.out.print((char) (d[i] + 65) + " ");
for (int i = 0; i < 3; i++) {
int t = 0;
for (int j = 0; j < 3; j++) {
t = t + (d[j] * b[j][i]);
}
c[i] = t % 26;
}
System.out.print("\nDecrypted Cipher Text: ");
for (int i = 0; i < 3; i++)
System.out.print((char) (c[i] + 65) + " ");
scanner.close();
}
}
pLAYFAIR:
key=input("Enter key")
key=key.replace(" ", "")
key=key.upper()
def matrix(x,y,initial):
return [[initial for i in range(x)] for j in range(y)]
result=list()
for c in key: #storing key
if c not in result:
if c=='J':
result.append('I')
else:
result.append(c)
flag=0
for i in range(65,91): #storing other character
if chr(i) not in result:
if i==73 and chr(74) not in result:
result.append("I")
flag=1
elif flag==0 and i==73 or i==74:
pass
else:
result.append(chr(i))
k=0
my_matrix=matrix(5,5,0) #initialize matrix
for i in range(0,5): #making matrix
for j in range(0,5):
my_matrix[i][j]=result[k]
k+=1
def locindex(c): #get location of each character
loc=list()
if c=='J':
c='I'
for i ,j in enumerate(my_matrix):
for k,l in enumerate(j):
if c==l:
loc.append(i)
loc.append(k)
return loc
def encrypt(): #Encryption
msg=str(input("ENTER MSG:"))
msg=msg.upper()
msg=msg.replace(" ", "")
i=0
for s in range(0,len(msg)+1,2):
if s<len(msg)-1:
if msg[s]==msg[s+1]:
msg=msg[:s+1]+'X'+msg[s+1:]
if len(msg)%2!=0:
msg=msg[:]+'X'
print("CIPHER TEXT:",end=' ')
while i<len(msg):
loc=list()
loc=locindex(msg[i])
loc1=list()
loc1=locindex(msg[i+1])
if loc[1]==loc1[1]:
print("{}{}".format(my_matrix[(loc[0]+1)%5]
[loc[1]],my_matrix[(loc1[0]+1)%5][loc1[1]]),end=' ')
elif loc[0]==loc1[0]:
print("{}{}".format(my_matrix[loc[0]]
[(loc[1]+1)%5],my_matrix[loc1[0]][(loc1[1]+1)%5]),end=' ')
else:
print("{}{}".format(my_matrix[loc[0]]
[loc1[1]],my_matrix[loc1[0]][loc[1]]),end=' ')
i=i+2
def decrypt(): #decryption
msg=str(input("ENTER CIPHER TEXT:"))
msg=msg.upper()
msg=msg.replace(" ", "")
print("PLAIN TEXT:",end=' ')
i=0
while i<len(msg):
loc=list()
loc=locindex(msg[i])
loc1=list()
loc1=locindex(msg[i+1])
if loc[1]==loc1[1]:
print("{}{}".format(my_matrix[(loc[0]-1)%5]
[loc[1]],my_matrix[(loc1[0]-1)%5][loc1[1]]),end=' ')
elif loc[0]==loc1[0]:
print("{}{}".format(my_matrix[loc[0]][(loc[1]-
1)%5],my_matrix[loc1[0]][(loc1[1]-1)%5]),end=' ')
else:
print("{}{}".format(my_matrix[loc[0]]
[loc1[1]],my_matrix[loc1[0]][loc[1]]),end=' ')
i=i+2
while(1):
choice=int(input("\n 1.Encryption \n 2.Decryption: \n 3.EXIT"))
if choice==1:
encrypt()
elif choice==2:
decrypt()
elif choice==3:
exit()
else:
print("Choose correct choice")
VIGNERE:
import java.util.Scanner;
public class StreamCipher {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the length of the key stream: ");
int kl = scanner.nextInt();
System.out.print("Enter the length of the plain text stream (Without spaces): ");
int pl = scanner.nextInt();
System.out.println("\nEnter the Key: ");
char[] k = new char[kl];
for (int i = 0; i < kl; ++i) {
k[i] = scanner.next().charAt(0);
}
System.out.println("\nEnter the Plain text: ");
char[] p = new char[pl];
for (int i = 0; i < pl; ++i) {
p[i] = scanner.next().charAt(0);
}
int[][] s = new int[3][pl];
for (int i = 0; i < pl; ++i) {
if (65 <= p[i] && p[i] <= 91)
s[0][i] = p[i] % 65;
else
s[0][i] = p[i] % 97;
}
for (int i = 0; i < pl; ++i)
System.out.print(s[0][i] + " ");
int count = 0;
while (count < pl) {
for (int i = 0; i < kl; ++i) {
if (65 <= k[i] && k[i] <= 91)
s[1][count + i] = k[i] % 65;
else
s[1][count + i] = k[i] % 97;
}
count = count + kl;
}
System.out.println("\n");
for (int i = 0; i < pl; ++i)
System.out.print(s[1][i] + " ");
System.out.println("\n");
for (int i = 0; i < pl; ++i)
System.out.print(s[2][i] + " ");
System.out.println("\n\nThe cipher text is: ");
char[] cipher = new char[kl];
for (int i = 0; i < pl; ++i) {
s[2][i] = (s[0][i] + s[1][i]) % 26;
cipher[i] = (char) (s[2][i] + 65);
System.out.print(cipher[i] + " ");
}
scanner.close();
}
}
Railfence :
import java.util.Scanner;
public class CipherText {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a string: ");
String inputString = scanner.next();
char[] s = inputString.toCharArray();
char[] a = new char[10];
char[] b = new char[10];
int k = 0, l = 0, m = 0;
for (int i = 0; i < s.length; i++) {
if (i % 2 == 0) {
a[k] = s[i];
k++;
} else {
b[l] = s[i];
l++;
}
}
System.out.println("Even positions: ");
for (int i = 0; i < k; i++) {
System.out.print(a[i] + " ");
s[m] = a[i];
m++;
}
System.out.println("\nOdd positions: ");
for (int i = 0; i < l; i++) {
System.out.print(b[i] + " ");
s[m] = b[i];
m++;
}
System.out.println("\n\nCipher text is: " + new String(s));
scanner.close();
}
}
AFFINE CIPHER:
import java.util.*;
public class Affine
{
static int a;
static int b;
public static String encrypt(int a,int b,String msg){
String cipher =" ";
for(int i=0;i<msg.length();i++){
if (msg.charAt(i)!=' '){
cipher=cipher+(char)((((a * (msg.charAt(i) - 'A')) + b)
% 26) + 'A');
}
else{
cipher=cipher+msg.charAt(i);
}
}
return cipher;
}
public static String decrypt(int a,int b,String cipher){
String msg = "";
int a_inv = 0;
int flag = 0;
for(int i=0;i<26;i++){
flag=(a*i)%26;
if(flag==1){
a_inv=i;
}
}
for (int i = 0; i < cipher.length(); i++)
{
if (cipher.charAt(i) != ' ')
{
msg = msg + (char) (((a_inv *
((cipher.charAt(i) + 'A' - b)) % 26)) + 'A');
}
else //else simply append space character
{
msg += cipher.charAt(i);
}
}
return msg;
}
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
a=sc.nextInt();
b=sc.nextInt();
String plain = sc.next();
System.out.println(plain);
String encrypted = encrypt(a,b,plain);
System.out.println("CIPHER TEXT:");
System.out.println(encrypted);
String decrypted = decrypt(a,b,encrypted);
System.out.println("DECRYPTED CIPHER TEXT:");
System.out.println(decrypted);
sc.close();
}
}
DES:
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import java.security.SecureRandom;
import java.util.Base64;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;
class Des {
private static final String ALGORITHM = "DES/CBC/PKCS5Padding";
private static final String KEY_ALGORITHM = "DES";
private Cipher encryptCipher;
private Cipher decryptCipher;
public Des(byte[] key, byte[] iv) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(key, KEY_ALGORITHM);
IvParameterSpec ivSpec = new IvParameterSpec(iv);
encryptCipher = Cipher.getInstance(ALGORITHM);
encryptCipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
decryptCipher = Cipher.getInstance(ALGORITHM);
decryptCipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
}
public String encrypt(String str) throws Exception {
byte[] utf8 = str.getBytes("UTF-8");
byte[] encrypted = encryptCipher.doFinal(utf8);
return Base64.getEncoder().encodeToString(encrypted);
}
public String decrypt(String str) throws Exception {
byte[] dec = Base64.getDecoder().decode(str);
byte[] decrypted = decryptCipher.doFinal(dec);
return new String(decrypted, "UTF-8");
}
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
final String secretText = sc.nextLine();
System.out.println("Secret Text: " + secretText);
// Generate a random key securely
SecureRandom random = new SecureRandom();
byte[] key = new byte[8];
random.nextBytes(key);
// Generate a random initialization vector
byte[] iv = new byte[8];
random.nextBytes(iv);
Des encrypter = new Des(key, iv);
String encrypted = encrypter.encrypt(secretText);
System.out.println("Encrypted Value: " + encrypted);
String decrypted = encrypter.decrypt(encrypted);
System.out.println("Decrypted: " + decrypted);
sc.close();
}
}
MD5:
Python 3 code to demonstrate the
# working of MD5 (string - hexadecimal)
import hashlib
# initializing string
str2hash = input("ENTER MESSAGE :");
# encoding GeeksforGeeks using encode()
# then sending to md5()
result = hashlib.md5(str2hash.encode())
# printing the equivalent hexadecimal value.
print("The hexadecimal equivalent of hash is : ", end ="")
print(result.hexdigest())
SHA ALGORITHM:
import sys
import hashlib
if sys.version_info < (3, 6):
import sha3
# initiating the "s" object to use the
# sha3_224 algorithm from the hashlib module.
s = hashlib.sha3_224()
# will output the name of the hashing algorithm currently in use.
print(s.name)
# will output the Digest-Size of the hashing algorithm being used.
print(s.digest_size)
message=input()
# providing the input to the hashing algorithm.
s.update(message.encode())
print(s.hexdigest())
DIGITAL SIGNATURE:
import hashlib
import base64
from Crypto.PublicKey import DSA
from Crypto.Signature import DSS
from Crypto.Random import get_random_bytes
def sign(datafile, prvKey):
with open(datafile, 'rb') as f:
message = f.read()
hash_object = hashlib.sha256(message)
hash_value = hash_object.digest()
signer = DSS.new(prvKey, 'fips-186-3')
signature = signer.sign(hash_value)
return signature
def verify(datafile, pubKey, sigbytes):
with open(datafile, 'rb') as f:
message = f.read()
hash_object = hashlib.sha256(message)
hash_value = hash_object.digest()
verifier = DSS.new(pubKey, 'fips-186-3')
try:
verifier.verify(hash_value, sigbytes)
return True
except ValueError:
return False
def main():
# Generate a key-pair
key = DSA.generate(1024)
pubk = key.publickey()
prvk = key
datafile = input("Enter the file name for Digital Signature : ")
sigbytes = sign(datafile, prvk)
print("Signature(in hex):", sigbytes.hex())
result = verify(datafile, pubk, sigbytes)
print("Signature Verification Result =", result)
if __name__ == "__main__":
main()
