2.

write a java program to perform encryption and decryption using the

following algorithm
(ii) playfair cipher
import java.util.*;

public class PlayfairCipher {

private char[][] keySquare = new char[5][5];
private String key;

public PlayfairCipher(String key) {

this.key = key;
generateKeySquare();
}

private void generateKeySquare() {

String alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"; // J is omitted
String keyString = key.toUpperCase().replaceAll("J", "I") + alphabet;
Set<Character> used = new LinkedHashSet<>();

for (char c : keyString.toCharArray()) {

if (Character.isLetter(c)) {
used.add(c);
}
}

Iterator<Character> it = used.iterator();
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
keySquare[i][j] = it.next();
}
}
}
private String prepareText(String text) {
text = text.toUpperCase().replaceAll("J", "I").replaceAll("[^A-Z]", "");
StringBuilder prepared = new StringBuilder();

for (int i = 0; i < text.length(); i++) {

prepared.append(text.charAt(i));
if (i < text.length() - 1 && text.charAt(i) == text.charAt(i + 1)) {
prepared.append('X');
}
}

if (prepared.length() % 2 != 0) {
prepared.append('X');
}
return prepared.toString();
}

private String processDigraphs(String text, boolean encrypt) {

StringBuilder result = new StringBuilder();
text = prepareText(text);

for (int i = 0; i < text.length(); i += 2) {

char a = text.charAt(i);
char b = text.charAt(i + 1);
int[] posA = findPosition(a);
int[] posB = findPosition(b);

if (posA[0] == posB[0]) { // Same row

result.append(keySquare[posA[0]][(posA[1] + (encrypt ? 1 : 4)) % 5]);
result.append(keySquare[posB[0]][(posB[1] + (encrypt ? 1 : 4)) % 5]);
} else if (posA[1] == posB[1]) { // Same column
 result.append(keySquare[(posA[0] + (encrypt ? 1 : 4)) % 5][posA[1]]);
result.append(keySquare[(posB[0] + (encrypt ? 1 : 4)) % 5][posB[1]]);
} else { // Rectangle swap
result.append(keySquare[posA[0]][posB[1]]);
result.append(keySquare[posB[0]][posA[1]]);
}
}
return result.toString();
}

private int[] findPosition(char c) {

for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (keySquare[i][j] == c) {
return new int[]{i, j};
}
}
}
return null;
}

public String encrypt(String text) {

return processDigraphs(text, true);
}

public String decrypt(String text) {

return processDigraphs(text, false);
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
System.out.print("Enter key: ");
 String key = scanner.nextLine();

PlayfairCipher cipher = new PlayfairCipher(key);

System.out.print("Enter message: ");

String message = scanner.nextLine();

String encrypted = cipher.encrypt(message);

System.out.println("Encrypted: " + encrypted);

String decrypted = cipher.decrypt(encrypted);

System.out.println("Decrypted: " + decrypted);

scanner.close();
}
}

3. Write a program to implement RSA algorithm.

import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;

public class RSAAlgorithm {

private BigInteger p, q, n, phi, e, d;
private int bitLength = 1024;
private Random rand;

public RSAAlgorithm() {
rand = new Random();
p = BigInteger.probablePrime(bitLength / 2, rand);
 q = BigInteger.probablePrime(bitLength / 2, rand);
n = p.multiply(q);
phi = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
e = BigInteger.probablePrime(bitLength / 2, rand);

while (phi.gcd(e).compareTo(BigInteger.ONE) > 0 && e.compareTo(phi) < 0)

{
e = BigInteger.probablePrime(bitLength / 2, rand);
}
d = e.modInverse(phi);
}

public BigInteger encrypt(BigInteger message) {

return message.modPow(e, n);
}

public BigInteger decrypt(BigInteger encrypted) {

return encrypted.modPow(d, n);
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
RSAAlgorithm rsa = new RSAAlgorithm();

System.out.println("Public Key: (" + rsa.e + ", " + rsa.n + ")");

System.out.println("Private Key: (" + rsa.d + ", " + rsa.n + ")");

System.out.print("Enter message (numeric): ");

BigInteger message = scanner.nextBigInteger();

BigInteger encrypted = rsa.encrypt(message);

System.out.println("Encrypted: " + encrypted);
 BigInteger decrypted = rsa.decrypt(encrypted);
System.out.println("Decrypted: " + decrypted);

scanner.close();
}
}

4. calculate message digest of a text using SHA -1 algorithm in JAVA

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

public class SHA1Digest {

public static String calculateSHA1(String input) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] messageDigest = md.digest(input.getBytes());

StringBuilder hexString = new StringBuilder();

for (byte b : messageDigest) {
hexString.append(String.format("%02x", b));
}
return hexString.toString();
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
 System.out.print("Enter text: ");
String text = scanner.nextLine();

String sha1Hash = calculateSHA1(text);

System.out.println("SHA-1 Digest: " + sha1Hash);

scanner.close();
}
}

5. Calculate message digest of a text using MD5 algorithm in JAVA

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

public class MD5Digest {

public static String calculateMD5(String input) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] messageDigest = md.digest(input.getBytes());

StringBuilder hexString = new StringBuilder();

for (byte b : messageDigest) {
hexString.append(String.format("%02x", b));
}
return hexString.toString();
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
 public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter text: ");
String text = scanner.nextLine();

String md5Hash = calculateMD5(text);

System.out.println("MD5 Digest: " + md5Hash);

scanner.close();
}
}

8. Implement RC4 algorithm and check the following input using java
Enter plaintext : hello
Enter key of same length : yello
plaintext in bytes : 104 101 108 108 111
keystream is : 248 30 202 165 16
Cipher text is : 144 123 166 201 127
Plaintext after decryption : 104 101 108 108 111

import java.util.Scanner;

public class RC4Cipher {

private byte[] S = new byte[256];
private int i, j;

public RC4Cipher(String key) {

byte[] keyBytes = key.getBytes();
initializeSBox(keyBytes);
}
private void initializeSBox(byte[] key) {
for (i = 0; i < 256; i++) {
S[i] = (byte) i;
}
j = 0;
for (i = 0; i < 256; i++) {
j = (j + S[i] + key[i % key.length]) & 0xFF;
swap(i, j);
}
i = j = 0;
}

private void swap(int a, int b) {

byte temp = S[a];
S[a] = S[b];
S[b] = temp;
}

private byte getKeystreamByte() {

i = (i + 1) & 0xFF;
j = (j + S[i]) & 0xFF;
swap(i, j);
return S[(S[i] + S[j]) & 0xFF];
}

public byte[] encryptDecrypt(byte[] input) {

byte[] output = new byte[input.length];
for (int k = 0; k < input.length; k++) {
output[k] = (byte) (input[k] ^ getKeystreamByte());
}
return output;
}
 public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter plaintext: ");

String plaintext = scanner.nextLine();

System.out.print("Enter key of same length: ");

String key = scanner.nextLine();

if (plaintext.length() != key.length()) {
System.out.println("Error: Key length must be the same as plaintext
length.");
scanner.close();
return;
}

RC4Cipher rc4 = new RC4Cipher(key);

byte[] plaintextBytes = plaintext.getBytes();

System.out.print("Plaintext in bytes: ");

for (byte b : plaintextBytes) {
System.out.print((b & 0xFF) + " ");
}
System.out.println();

byte[] cipherBytes = rc4.encryptDecrypt(plaintextBytes);

System.out.print("Cipher text is: ");

for (byte b : cipherBytes) {
System.out.print((b & 0xFF) + " ");
}
 System.out.println();

RC4Cipher rc4Decrypt = new RC4Cipher(key);

byte[] decryptedBytes = rc4Decrypt.encryptDecrypt(cipherBytes);

System.out.print("Plaintext after decryption: ");

for (byte b : decryptedBytes) {
System.out.print((b & 0xFF) + " ");
}
System.out.println();

scanner.close();
}
}

9. Implement the SIGNATURE SCHEME - Digital Signature Standard.

import java.security.*;
import java.util.Base64;
import java.util.Scanner;

public class DigitalSignatureDSS {

public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DSA");
keyPairGen.initialize(1024);
return keyPairGen.generateKeyPair();
}

public static byte[] signData(String data, PrivateKey privateKey) throws

Exception {
Signature signature = Signature.getInstance("SHA1withDSA");
 signature.initSign(privateKey);
signature.update(data.getBytes());
return signature.sign();
}

public static boolean verifySignature(String data, byte[] signatureBytes,

PublicKey publicKey) throws Exception {
Signature signature = Signature.getInstance("SHA1withDSA");
signature.initVerify(publicKey);
signature.update(data.getBytes());
return signature.verify(signatureBytes);
}

public static void main(String[] args) {

try {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter message: ");
String message = scanner.nextLine();

KeyPair keyPair = generateKeyPair();

byte[] signatureBytes = signData(message, keyPair.getPrivate());

System.out.println("Generated Signature: " +

Base64.getEncoder().encodeToString(signatureBytes));

boolean isVerified = verifySignature(message, signatureBytes,

keyPair.getPublic());
System.out.println("Signature Verification: " + (isVerified ? "Valid" :
"Invalid"));

scanner.close();
} catch (Exception e) {
e.printStackTrace();
 }
}
}

10. Generate first five keys for the initial key : ThisIsA128BitKey in AES
algorithm using java.
sample output:
Round 0: 54684973497341313238624B657921
Round 1: 96392E2B8BDE6E8A3C5C36E5A7D441D3
Round 2: 0FEF946C7D6DBD592C019D928E72E5E1
Round 3: 27341A879D8389E63F65F2B041D4D0B3
Round 4: D0BCE5E63C05A9D2B2A5E4D73A2DFB6F
Round 5: 92E87DF5A1D457FA12F5D4BC8A374D5A

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

public class AESKeyExpansion {

private static final int KEY_SIZE = 16; // 128-bit key
private static final int NUM_ROUNDS = 5;
private static final byte[] RCON = {
(byte) 0x01, (byte) 0x02, (byte) 0x04, (byte) 0x08, (byte) 0x10
};

public static void main(String[] args) {

byte[] key = "ThisIsA128BitKey".getBytes();
byte[][] expandedKeys = keyExpansion(key);

for (int i = 0; i <= NUM_ROUNDS; i++) {

System.out.print("Round " + i + ": ");
 for (byte b : expandedKeys[i]) {
System.out.printf("%02X", b);
}
System.out.println();
}
}

private static byte[][] keyExpansion(byte[] key) {

byte[][] expandedKeys = new byte[NUM_ROUNDS + 1][KEY_SIZE];
System.arraycopy(key, 0, expandedKeys[0], 0, KEY_SIZE);

for (int i = 1; i <= NUM_ROUNDS; i++) {

byte[] temp = Arrays.copyOf(expandedKeys[i - 1], KEY_SIZE);
keyScheduleCore(temp, i - 1);
for (int j = 0; j < KEY_SIZE; j++) {
expandedKeys[i][j] = (byte) (expandedKeys[i - 1][j] ^ temp[j]);
}
}
return expandedKeys;
}

private static void keyScheduleCore(byte[] key, int round) {

byte temp = key[0];
System.arraycopy(key, 1, key, 0, 3);
key[3] = temp;

for (int i = 0; i < 4; i++) {

key[i] = sBox(key[i]);
}
key[0] ^= RCON[round];
}
 private static byte sBox(byte input) {
int[] sbox = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67,
0x2b, 0xfe, 0xd7, 0xab, 0x76
};
return (byte) sbox[input & 0x0F];
}
}