1.CasearCipher
import java.util.Scanner;
public class CaesarCipher {
public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
// Encryption method
public static String encrypt(String plainText, int shiftKey) {
plainText = plainText.toLowerCase();
String cipherText = "";
for (int i = 0; i < plainText.length(); i++) {
char currentChar = plainText.charAt(i);
if (ALPHABET.indexOf(currentChar) != -1) { // Check if it's a letter
int charPosition = ALPHABET.indexOf(currentChar);
int keyVal = (shiftKey + charPosition) % 26;
char replaceVal = ALPHABET.charAt(keyVal);
cipherText += replaceVal;
} else {
cipherText += currentChar; // If not a letter, just append it as is
}
}
return cipherText;
}
// Decryption method
public static String decrypt(String cipherText, int shiftKey) {
cipherText = cipherText.toLowerCase();
String plainText = "";
for (int i = 0; i < cipherText.length(); i++) {
char currentChar = cipherText.charAt(i);
if (ALPHABET.indexOf(currentChar) != -1) { // Check if it's a letter
2.ModifiedCaesarCipherDemo
import java.util.*;
class CaesarCipher {
private final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
// Encryption method
public String encrypt(String plainText, int shiftKey) {
plainText = plainText.toLowerCase();
String cipherText = "";
for (int i = 0; i < plainText.length(); i++) {
char currentChar = plainText.charAt(i);
if (ALPHABET.indexOf(currentChar) != -1) { // Only encrypt alphabetic characters
int charPosition = ALPHABET.indexOf(currentChar);
int keyVal = (shiftKey + charPosition) % 26;
char replaceVal = ALPHABET.charAt(keyVal);
cipherText += replaceVal;
} else {
cipherText += currentChar; // Keep non-alphabetic characters unchanged
}
}
return cipherText;
}
// Decryption method
public String decrypt(String cipherText, int shiftKey) {
cipherText = cipherText.toLowerCase();
String plainText = "";
for (int i = 0; i < cipherText.length(); i++) {
char currentChar = cipherText.charAt(i);
if (ALPHABET.indexOf(currentChar) != -1) { // Only decrypt alphabetic characters
int charPosition = ALPHABET.indexOf(currentChar);
int keyVal = (charPosition - shiftKey) % 26;
if (keyVal < 0) {
keyVal = ALPHABET.length() + keyVal;
}
char replaceVal = ALPHABET.charAt(keyVal);
plainText += replaceVal;
} else {
plainText += currentChar; // Keep non-alphabetic characters unchanged
}
}
return plainText;
}
}
class ModifiedCaesarCipherDemo {
public static void main(String args[]) throws Exception {
Scanner input = new Scanner(System.in);
// Taking plain text input
System.out.println("Type Your Plain Text:");
String plainText = input.nextLine();
// Taking shift key input
System.out.println("Type Your ShiftKey Length:");
int shiftKey = input.nextInt();
// Creating CaesarCipher object
CaesarCipher cc = new CaesarCipher();
// Encrypting the plain text
String cipherText = cc.encrypt(plainText, shiftKey);
System.out.println("Your PlainText: " + plainText);
System.out.println("Your CipherText: " + cipherText);
// Decrypting the cipher text
String decryptedText = cc.decrypt(cipherText, shiftKey);
System.out.println("Your Decrypted Plain Text: " + decryptedText);
input.close(); // Closing the Scanner to avoid resource leak
}
}
3.The MonoAlphabetic
import java.util.*;
public class MonoAlphabetic {
public static void main(String args[]) {
char ch, ch1;
int i, pos;
String input = "";
String output = "";
Scanner sc = new Scanner(System.in);
String plainText = "abcdefghijklmnopqrstuvwxyz";
String cipherText = "GHDWVFJEBDHVYUCDKLMNOPQRSZT"; // Same length as plainText
System.out.println("\nPlainText: " + plainText);
System.out.println("\nCipherText: " + cipherText);
System.out.println("\nUsing MonoAlphabetic Cipher:");
System.out.println("\nEnter Data To Encrypt:");
input = sc.nextLine().toLowerCase(); // Convert input to lowercase for consistency
// Encrypting the input
for (i = 0; i < input.length(); i++) {
ch = input.charAt(i);
if (plainText.indexOf(ch) != -1) { // Only encrypt alphabetic characters
pos = plainText.indexOf(ch);
ch1 = cipherText.charAt(pos);
output = output + ch1;
} else {
output = output + ch; // Non-alphabetic characters stay the same
}
}
System.out.println("\nEncrypted Output: " + output);
sc.close(); // Close the scanner to avoid resource leak
}
}
4.The PolyAlphabetic
import java.util.*;
class PolyAlphabet {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
String p = "", c = "", k = "", l = "abcdefghijklmnopqrstuvwxyz";
System.out.print("Give the plain text: ");
p = sc.nextLine().toLowerCase(); // Convert to lowercase for consistency
System.out.print("Give the Key: ");
k = sc.nextLine().toLowerCase(); // Convert to lowercase for consistency
int ky = k.length();
int pln = p.length();
// Expand the key to match the length of the plaintext
StringBuilder expandedKey = new StringBuilder(k);
while (expandedKey.length() < pln) {
expandedKey.append(k);
}
// Trim the expanded key to the length of the plaintext
k = expandedKey.substring(0, pln);
// Encrypting the plaintext
for (int j = 0; j < pln; j++) {
if (l.indexOf(p.charAt(j)) != -1) { // Check if character is in the alphabet
c += l.charAt((l.indexOf(k.charAt(j)) + l.indexOf(p.charAt(j))) % 26);
} else {
c += p.charAt(j); // Keep non-alphabetic characters unchanged
}
}
c = c.toUpperCase();
System.out.println("Cipher text: " + c);
// Decrypting the cipher text
String plDecrypted = "";
for (int r = 0; r < pln; r++) {
if (l.indexOf(c.charAt(r)) != -1) { // Check if character is in the alphabet
plDecrypted += l.charAt((l.indexOf(c.charAt(r)) - l.indexOf(k.charAt(r)) + 26) % 26);
} else {
plDecrypted += c.charAt(r); // Keep non-alphabetic characters unchanged
}
}
System.out.println("Decrypted text: " + plDecrypted);
sc.close(); // Close the scanner to avoid resource leak
}
}
5.RSA
import java.math.*;
import java.util.*;
class RSA {
public static void main(String args[]) {
BigInteger one = BigInteger.ONE, p, q, n, φ, E, D;
Scanner s = new Scanner(System.in);
System.out.println("Enter A's prime number:");
p = s.nextBigInteger();
System.out.println("Enter B's prime number:");
q = s.nextBigInteger();
n = p.multiply(q);
φ = (p.subtract(one)).multiply(q.subtract(one)); // φ(n) = (p-1)(q-1)
// Get the public key E
E = BigInteger.ZERO;
do {
System.out.println("Enter Public key (E):");
E = s.nextBigInteger();
} while (!((φ.gcd(E)).equals(one) && E.compareTo(one) > 0 && E.compareTo(φ) < 0));
// Calculate D, the modular multiplicative inverse of E mod φ(n)
D = E.modInverse(φ);
System.out.println("Enter Plain text:");
String text = s.next(); // Changed to next() for single word input
StringBuilder out = new StringBuilder();
StringBuilder in = new StringBuilder();
for (int i = 0; i < text.length(); i++) {
BigInteger T = BigInteger.valueOf((int) text.charAt(i)); // Convert char to BigInteger
BigInteger O = T.modPow(E, n); // Encrypt
out.append(O.toString()).append(" "); // Store encrypted value as string
BigInteger TF = O.modPow(D, n); // Decrypt
in.append((char) TF.intValue()); // Append decrypted character
}
System.out.println("Encrypted text (Cipher Text): " + out.toString());
System.out.println("Decrypted text (Plain Text): " + in.toString());
s.close(); // Close scanner to avoid resource leak
}
}
6.Message Authentication Codes
import java.security.Key;import java.security.SecureRandom;import javax.crypto.KeyGenerator;import javax.crypto.Mac;
public class MacSample { public static void main(String args[]) throws Exception { // Creating a KeyGenerator object for HMAC KeyGenerator keyGen = KeyGenerator.getInstance("HmacSHA256"); // Creating a SecureRandom object SecureRandom secRandom = new SecureRandom(); // Initializing the KeyGenerator keyGen.init(256, secRandom); // Use 256 bits for HMAC-SHA256 // Creating/Generating a key Key key = keyGen.generateKey(); // Creating a Mac object Mac mac = Mac.getInstance("HmacSHA256"); // Initializing the Mac object mac.init(key); // Computing the Mac String msg = "Hi how are you"; byte[] bytes = msg.getBytes(); byte[] macResult = mac.doFinal(bytes); // Displaying the Mac result in hexadecimal format System.out.println("Mac result:"); System.out.println(bytesToHex(macResult)); } // Utility method to convert byte array to hex string public static String bytesToHex(byte[] bytes) { StringBuilder hexString = new StringBuilder(); for (byte b : bytes) { String hex = Integer.toHexString(0xff & b); if (hex.length() == 1) hexString.append('0'); hexString.append(hex); } return hexString.toString(); }}
import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
public class MacSample {
public static void main(String args[]) throws Exception {
// Creating a KeyGenerator object for HMAC
KeyGenerator keyGen = KeyGenerator.getInstance("HmacSHA256");
// Creating a SecureRandom object
SecureRandom secRandom = new SecureRandom();
// Initializing the KeyGenerator
keyGen.init(256, secRandom); // Use 256 bits for HMAC-SHA256
// Creating/Generating a key
Key key = keyGen.generateKey();
// Creating a Mac object
Mac mac = Mac.getInstance("HmacSHA256");
// Initializing the Mac object
mac.init(key);
// Computing the Mac
String msg = "Hi how are you";
byte[] bytes = msg.getBytes();
byte[] macResult = mac.doFinal(bytes);
// Displaying the Mac result in hexadecimal format
System.out.println("Mac result:");
System.out.println(bytesToHex(macResult));
}
// Utility method to convert byte array to hex string
public static String bytesToHex(byte[] bytes) {
StringBuilder hexString = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) hexString.append('0');
hexString.append(hex);
}
return hexString.toString();
}
}
7.Implement digital signature algorithms such as RSA-based signatures
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.util.Base64;
import java.util.Scanner;
public class DigitalSignature {
// Signing Algorithm
private static final String SIGNING_ALGORITHM = "SHA256withRSA";
private static final String RSA = "RSA";
// Function to implement Digital signature using SHA256 and RSA algorithm
public static byte[] createDigitalSignature(byte[] input, PrivateKey key) throws Exception {
Signature signature = Signature.getInstance(SIGNING_ALGORITHM);
signature.initSign(key);
signature.update(input);
return signature.sign();
}
// Generating the asymmetric key pair using SecureRandom class and RSA algorithm
public static KeyPair generateRSAKeyPair() throws Exception {
SecureRandom secureRandom = new SecureRandom();
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
keyPairGenerator.initialize(2048, secureRandom);
return keyPairGenerator.generateKeyPair();
}
// Function for Verification of the digital signature using the public key
public static boolean verifyDigitalSignature(byte[] input, byte[] signatureToVerify, PublicKey key) throws Exception {
Signature signature = Signature.getInstance(SIGNING_ALGORITHM);
signature.initVerify(key);
signature.update(input);
return signature.verify(signatureToVerify);
}
public static void main(String args[]) throws Exception {
String input = "GEEKSFORGEEKS IS A COMPUTER SCIENCE PORTAL";
KeyPair keyPair = generateRSAKeyPair();
// Function Call
byte[] signature = createDigitalSignature(input.getBytes(), keyPair.getPrivate());
System.out.println("Signature Value (Hex): " + bytesToHex(signature));
System.out.println("Verification: " + verifyDigitalSignature(input.getBytes(), signature, keyPair.getPublic()));
}
// Utility method to convert byte array to hex string
public static String bytesToHex(byte[] bytes) {
StringBuilder hexString = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) hexString.append('0');
hexString.append(hex);
}
return hexString.toString();
}
}
8.Key Exchange using Diffie-Hellman
import java.math.BigInteger;
import java.util.Scanner;
public class DiffieHellman {
final static BigInteger one = new BigInteger("1");
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
// Input first prime number
System.out.println("Enter the first prime number:");
BigInteger p = getNextPrime(sc.next());
// Input second prime number
System.out.println("Enter the second prime number:");
BigInteger g = new BigInteger(sc.next());
// Input random number for Person A
System.out.println("Person A, enter your random number (x):");
BigInteger a = new BigInteger(sc.next());
// Calculate result for Person A
BigInteger resultA = g.modPow(a, p);
System.out.println("Person A sends " + resultA + " to Person B");
// Input random number for Person B
System.out.println("Person B, enter your random number (y):");
BigInteger b = new BigInteger(sc.next());
// Calculate result for Person B
BigInteger resultB = g.modPow(b, p);
System.out.println("Person B sends " + resultB + " to Person A");
// Calculate the shared secret keys
BigInteger keyA = resultB.modPow(a, p);
BigInteger keyB = resultA.modPow(b, p);
// Output the calculated keys
System.out.println("Key A calculates: " + keyA);
System.out.println("Key B calculates: " + keyB);
// Validate that both keys are equal
if (keyA.equals(keyB)) {
System.out.println("Keys match! Shared secret established.");
} else {
System.out.println("Keys do not match! Something went wrong.");
}
sc.close();
}
public static BigInteger getNextPrime(String input) {
BigInteger test = new BigInteger(input);
while (!test.isProbablePrime(99)) {
test = test.add(one);
}
return test;
}
}
