Exp No : 1(A) DATE : 06/08/2024

CAESAR CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

SERVER:

package caesar1;
import java.io.*;
import java.net.*;
public class server {
public static StringBuffer decrypt(String cipher, int shift) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < cipher.length(); i++) {
if (Character.isUpperCase(cipher.charAt(i))) {
char ch = (char) (((int) cipher.charAt(i) + shift - 65) % 26 + 65);
result.append(ch);
} else {
char ch = (char) (((int) cipher.charAt(i) + shift - 97) % 26 + 97);
result.append(ch);
}}
return result;
}
public static void main(String[] args){
int shiftCount=3;
try{

1
 ServerSocket ss=new ServerSocket(6666);
Socket s=ss.accept();//establishes connection
DataInputStream dis=new DataInputStream(s.getInputStream());
String str=(String)dis.readUTF();
String cipher=str;
System.out.println("Decryption side");
System.out.println("Encrypted Cipher: " + cipher);
String decryptedPlainText = decrypt(cipher, 26 - shiftCount).toString();
System.out.println("Decrypted Plain Text : " + decryptedPlainText);
ss.close();
}catch(Exception e){System.out.println(e);}
}
}

CLIENT:

package caesar1;
import java.util.Scanner;
import java.io.*;
import java.net.*;
public class client {
public static StringBuffer encrypt(String text, int shift) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < text.length(); i++) {
if (Character.isUpperCase(text.charAt(i))) {
char ch = (char) (((int) text.charAt(i) +shift - 65) % 26 + 65);
result.append(ch);
} else {
char ch = (char) (((int) text.charAt(i) + shift - 97) % 26 + 97);
result.append(ch);
}}
return result;
}
public static void main(String[] args) {
Scanner obj=new Scanner(System.in);
System.out.println("Caesar Cipher Example");
System.out.println("Encryption side");
System.out.println("Enter text to encrypt:");
String originalText=obj.nextLine();
int shiftCount = 3;
System.out.println("Text : " + originalText);
String cipher = encrypt(originalText, shiftCount).toString();
System.out.println("Encrypted Cipher: " + cipher);
try{
Socket s=new Socket("localhost",6666);
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
dout.writeUTF(cipher);
dout.flush();
dout.close();
s.close();

2
 }catch(Exception e){System.out.println(e);}
} }

OUTPUT:

RESULT:

3
Exp No : 1(B) DATE : 06/08/2024
AFFINE CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

SERVER:

package affine;

import java.io.*;
import java.net.*;
public class server {

static final int M = 5;

static final int C = 9;
static int modInverse(int a, int m) {
for (int x = 1; x < m; x++) {
if (((a % m) * (x % m)) % m == 1) {
return x;
}
}
return -1;
}
static String decryptMessage(String ciphertext) {
StringBuilder pt = new StringBuilder();

4
 int aInverse = modInverse(M, 26);
if (aInverse == -1) {
return "Inverse doesn't exist";
}
for (int i = 0; i < ciphertext.length(); i++) {
char ch = ciphertext.charAt(i);
if (Character.isLetter(ch)) {
if (Character.isUpperCase(ch)) {
int x = (aInverse * (ch - 'A' - C + 26)) % 26;
pt.append((char) ('A' + x));
} else {
int x = (aInverse * (ch - 'a' - C + 26)) % 26;
pt.append((char) ('a' + x));
}
} else {
pt.append(ch);
}
}
return pt.toString();
}
public static void main(String[] args){
try{
ServerSocket ss=new ServerSocket(6666);

Socket s=ss.accept();//establishes connection

DataInputStream dis=new DataInputStream(s.getInputStream());
String str=(String)dis.readUTF();
System.out.println("Encryted text "+str);
String et=str;
String dt = decryptMessage(et); // Decrypted Text
System.out.println("The Decrypted Text: " + dt);
ss.close();
}catch(Exception e){System.out.println(e);}
} }

CLIENT:

package affine;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class client {

static final int M = 5;

static final int C = 9;
static String encryptMessage(String pt) {
StringBuilder ciphertext = new StringBuilder();
for (int i = 0; i < pt.length(); i++) {
char ch = pt.charAt(i);

5
 if (Character.isLetter(ch)) {
if (Character.isUpperCase(ch)) {
ciphertext.append((char) ('A' + (M * (ch - 'A') + C) % 26));
} else {
ciphertext.append((char) ('a' + (M * (ch - 'a') + C) % 26));

}
} else {
ciphertext.append(ch);
} }
return ciphertext.toString();
}
public static void main(String[] args) {
try{
Scanner obj=new Scanner(System.in);
System.out.print("Key pair value is (5,9)"+"\n");
System.out.print("Enter text to encrypt: ");
String pt=obj.nextLine();
String et = encryptMessage(pt); // Encrypted Text
System.out.println("The Encrypted Text: " + et);
Socket s=new Socket("localhost",6666);
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
dout.writeUTF(et);
dout.flush();
dout.close();
s.close();
}catch(Exception e){System.out.println(e);}
}
}

OUTPUT:

RESULT:

6
Exp No : 1(C) DATE : 13/08/2024
HILL CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

SERVER:

package hill1;
import java.io.*;
import java.net.*;

public class Server {

public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8071);
Socket socket = serverSocket.accept();
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()))) {
String encryptedText = in.readLine();
System.out.println("Received encrypted text: " + encryptedText);
int n = Integer.parseInt(in.readLine());
if (n != 2 && n != 3) {
throw new IllegalArgumentException("Only 2x2 and 3x3 matrices are supported.");
}

7
 int[][] keyMatrix = new int[n][n];
for (int i = 0; i < n; i++) {
String[] values = in.readLine().split(" ");
for (int j = 0; j < n; j++) {
keyMatrix[i][j] = Integer.parseInt(values[j]);
}
}
int[][] inverseKeyMatrix;
try {
inverseKeyMatrix = invertMatrix(keyMatrix);
System.out.println("Inverse Key Matrix:");
printMatrix(inverseKeyMatrix);
} catch (ArithmeticException e) {
System.out.println("The key matrix is not invertible modulo 26.");
return;
}
String decryptedText = decrypt(encryptedText, inverseKeyMatrix);
System.out.println("Decrypted text: " + decryptedText);
} catch (IOException ex) {
System.out.println("Receiver error: " + ex.getMessage());
}
}
private static String decrypt(String ciphertext, int[][] inverseKeyMatrix) {
ciphertext = ciphertext.toUpperCase().replaceAll("[^A-Z]", "");
int[] encryptedText = new int[ciphertext.length()];
for (int i = 0; i < ciphertext.length(); i++) {
encryptedText[i] = ciphertext.charAt(i) - 'A';
}
int[] decryptedText = matrixMultiply(encryptedText, inverseKeyMatrix);
StringBuilder result = new StringBuilder();
for (int num : decryptedText) {
result.append((char) (num + 'A'));
}
return result.toString().replaceAll("X*$", "");
}
private static int[] matrixMultiply(int[] text, int[][] matrix) {
int blockSize = matrix.length;
int[] result = new int[text.length];
for (int i = 0; i < text.length; i += blockSize) {
for (int row = 0; row < blockSize; row++) {
int sum = 0;
for (int col = 0; col < blockSize; col++) {
sum += text[i + col] * matrix[row][col];
}
result[i + row] = (sum % 26 + 26) % 26;
} }
return result;
}
private static int[][] invertMatrix(int[][] matrix) {
int n = matrix.length;

8
 if (n == 2) {
return invert2x2Matrix(matrix);
} else if (n == 3) {
return invert3x3Matrix(matrix);
} else {
throw new IllegalArgumentException("Matrix inversion only implemented for 2x2 and3x3
matrices.");
}
}
private static int[][] invert2x2Matrix(int[][] matrix) {
int[][] adjugate = new int[2][2];
int det = determinant2x2(matrix);
int invDet = modularInverse(det, 26);
adjugate[0][0] = matrix[1][1];
adjugate[0][1] = -matrix[0][1];
adjugate[1][0] = -matrix[1][0];
adjugate[1][1] = matrix[0][0];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
adjugate[i][j] = (adjugate[i][j] * invDet) % 26;
if (adjugate[i][j] < 0) adjugate[i][j] += 26;
} }
return adjugate;
}
private static int[][] invert3x3Matrix(int[][] matrix) {
int[][] adjugate = new int[3][3];
int det = determinant3x3(matrix);
int invDet = modularInverse(det, 26);
adjugate[0][0] = matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1];
adjugate[0][1] = matrix[0][2] * matrix[2][1] - matrix[0][1] * matrix[2][2];
adjugate[0][2] = matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1];
adjugate[1][0] = matrix[1][2] * matrix[2][0] - matrix[1][0] * matrix[2][2];
adjugate[1][1] = matrix[0][0] * matrix[2][2] - matrix[0][2] * matrix[2][0];
adjugate[1][2] = matrix[0][2] * matrix[1][0] - matrix[0][0] * matrix[1][2];
adjugate[2][0] = matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0];
adjugate[2][1] = matrix[0][1] * matrix[2][0] - matrix[0][0] * matrix[2][1];
adjugate[2][2] = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
adjugate[i][j] = (adjugate[i][j] * invDet) % 26;
if (adjugate[i][j] < 0) adjugate[i][j] += 26;
}
}
return adjugate;
private static int determinant2x2(int[][] matrix) {
return (matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]) % 26; }}
private static int determinant3x3(int[][] matrix) {
return matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1])- matrix[0][1] *
(matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0])+ matrix[0][2] * (matrix[1][0] *
matrix[2][1] - matrix[1][1] * matrix[2][0]);

9
}

private static int modularInverse(int a, int m) {

a = a % m;
for (int x = 1; x < m; x++) {
if ((a * x) % m == 1) {
return x;
}
}
throw new ArithmeticException("Modular inverse does not exist");
}
private static void printMatrix(int[][] matrix) {
for (int[] row : matrix) {
for (int value : row) {
System.out.print(value + " ");
}
System.out.println();
}}}

CLIENT

package hill1;
import java.io.*;
import java.net.*;
import java.util.Scanner;

public class Client {

public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 8071);
BufferedReader userInput = new BufferedReader(new
InputStreamReader(System.in));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
int[][] keyMatrix = getKeyMatrixFromUser();
System.out.print("Enter message to send: ");
String plainText = userInput.readLine();
String encryptedText = encrypt(plainText, keyMatrix);
out.println(encryptedText);
System.out.println(encryptedText);
out.println(keyMatrix.length);
for (int[] row : keyMatrix) {
for (int value : row) {
out.print(value + " ");
}
out.println();
}
System.out.println("Sent encrypted text and key matrix");
} catch (IOException ex) {
System.out.println("Sender error: " + ex.getMessage());
} }

10
 private static int[][] getKeyMatrixFromUser() {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter matrix size (n x n): ");
int n = scanner.nextInt();
int[][] keyMatrix = new int[n][n];
System.out.println("Enter the key matrix values:");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
keyMatrix[i][j] = scanner.nextInt();
} }
return keyMatrix;
}
private static String encrypt(String plaintext, int[][] keyMatrix) {
plaintext = plaintext.toUpperCase().replaceAll("[^A-Z]", ""); // Clean and uppercase
int[] paddedText = padText(plaintext, keyMatrix.length);
int[] encryptedText = matrixMultiply(paddedText, keyMatrix);
StringBuilder result = new StringBuilder();
for (int num : encryptedText) {
result.append((char) (num + 'A'));
}
return result.toString();
}
private static int[] padText(String text, int blockSize) {
int padding = (blockSize - (text.length() % blockSize)) % blockSize;
StringBuilder sb = new StringBuilder(text);
for (int i = 0; i < padding; i++) {
sb.append('X');
}
text = sb.toString();
int[] paddedText = new int[text.length()];
for (int i = 0; i < text.length(); i++) {
paddedText[i] = text.charAt(i) - 'A';
}
return paddedText;
}
private static int[] matrixMultiply(int[] text, int[][] matrix) {
int blockSize = matrix.length;
int[] result = new int[text.length];
for (int i = 0; i < text.length; i += blockSize) {
for (int row = 0; row < blockSize; row++) {
int sum = 0;
for (int col = 0; col < blockSize; col++) {
sum += text[i + col] * matrix[row][col];
}
result[i + row] = (sum % 26 + 26) % 26;
}
}
return result;
}
}

11
OUTPUT:

RESULT:

12
Exp No : 1 (D) DATE : 13/08/2024
COLUMNAR CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

SERVER:

package columnar;
import java.io.*;
import java.net.*;

public class Server {

public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8081)) {
Socket socket = serverSocket.accept();

BufferedReader reader = new BufferedReader(new

InputStreamReader(socket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));

13
 String encryptedMessage = reader.readLine();
int columns = Integer.parseInt(reader.readLine());
int[] columnSequence = new int[columns];
for (int i = 0; i < columns; i++) {
columnSequence[i] = Integer.parseInt(reader.readLine());
}
System.out.println("Received Encrypted Message: " + encryptedMessage);
System.out.println("Received Columns: " + columns);
System.out.println("Received Column Sequence: " +
java.util.Arrays.toString(columnSequence));

String decryptedMessage = decryptMessage(encryptedMessage, columns,

columnSequence);
System.out.println("Decrypted Message: " + decryptedMessage);
writer.write(decryptedMessage + "\n");
writer.flush();

} catch (IOException e) {
e.printStackTrace();
}
}

public static String decryptMessage(String cipher, int columns, int[] columnSequence) {

int rows = cipher.length() / columns;
char[][] matrix = new char[rows][columns];
int k = 0;
for (int col : columnSequence) {
for (int i = 0; i < rows; i++) {
matrix[i][col - 1] = cipher.charAt(k++);
}
}
StringBuilder message = new StringBuilder();
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
if (matrix[i][j] != ' ') {
message.append(matrix[i][j]);
}
}
}
return message.toString();
}
}

CLIENT:

package columnar;
import java.io.*;
import java.net.*;
import java.util.*;

14
public class Client {
public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 8081)) {
BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
System.out.print("Enter the message to encrypt: ");
String message = userInput.readLine().replaceAll(" ", "");
System.out.print("Enter the number of columns: ");
int columns = Integer.parseInt(userInput.readLine());
int[] columnSequence = new int[columns];
System.out.println("Enter the column sequence (space-separated): ");
for (int i = 0; i < columns; i++) {
columnSequence[i] = Integer.parseInt(userInput.readLine());
}

String encryptedMessage = encryptMessage(message, columns, columnSequence);

System.out.println("Encrypted Message: " + encryptedMessage);
writer.write(encryptedMessage + "\n");
writer.write(columns + "\n");
for (int col : columnSequence) {
writer.write(col + "\n");
}
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
}

public static String encryptMessage(String msg, int columns, int[] columnSequence) {

int rows = (int) Math.ceil((double) msg.length() / columns);
char[][] matrix = new char[rows][columns];
int k = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
if (k < msg.length()) {
matrix[i][j] = msg.charAt(k++);
} else {
matrix[i][j] = ' ';
}
}
}
StringBuilder cipher = new StringBuilder();
for (int col : columnSequence) {
for (int i = 0; i < rows; i++) {
cipher.append(matrix[i][col - 1]);
}
}
return cipher.toString();

15
 }
}

OUTPUT:

RESULT:

16
Exp No : 1 (E) DATE : 13/08/2024
RAILFENCE CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

SERVER:

package railfence1;

import java.io.*;
import java.net.*;

public class Server {

public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8383)) {
Socket socket = serverSocket.accept();
BufferedReader reader = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));

String cipherText = reader.readLine();

System.out.println("Received Cipher Text: " + cipherText);

17
 String decryptedText = decryptRailFence(cipherText);
System.out.println("Decrypted Text: " + decryptedText);
writer.write(decryptedText + "\n");
writer.flush();

reader.close();
writer.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}

public static String decryptRailFence(String CT) {

int n = CT.length();
int p = n % 2;
StringBuilder PT = new StringBuilder();
if (p == 0) {
int j = 0;
for (int i = n / 2; i < n; i++) {
PT.append(CT.charAt(j)).append(CT.charAt(i));
j++;
}
} else {
int j = 0;
for (int i = (n / 2) + 1; i < n; i++) {

PT.append(CT.charAt(j)).append(CT.charAt(i));
j++;
}
PT.append(CT.charAt(j));
}
return PT.toString();
}
}

CLIENT:

package railfence1;
import java.io.*;
import java.net.*;

public class Client {

public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 8383)) {
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));

System.out.println("Enter the message: ");

18
 String message = userInput.readLine();
String cipherText = encryptRailFence(message);
System.out.println("Encrypted Text: " + cipherText);

writer.write(cipherText + "\n");
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String encryptRailFence(String PT) {
int n = PT.length();
StringBuilder CT = new StringBuilder();

for (int i = 0; i < n; i += 2)

CT.append(PT.charAt(i));
for (int i = 1; i < n; i += 2)
CT.append(PT.charAt(i));

return CT.toString();
}
}

OUTPUT:

RESULT:

19
Exp No : 2 (A) DATE : 20/08/2024
CRYPTOGRAPHIC ATTACK-CAESAR CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

import java.util.*;
public class Attackcipher {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter Plain Text: ");
String plain = sc.nextLine();
System.out.println("Enter Cipher Text: ");
String cipher = sc.nextLine();
int pl = plain.length();
int cl = cipher.length();
int key, check, count = 1;
if(pl!=cl) {
System.out.println("Lengths of texts inconsistent!");
}else {
key = cipher.charAt(0) - plain.charAt(0);
if(key<0) key += 26;
for(int i=0; i<pl; i++) {
check = cipher.charAt(i) - plain.charAt(i);
if(check<0)check += 26;
if(key!=check) {
System.out.println("Invalid Cipher Text");
count = 0;
break;
} } if(count==1)

20
 System.out.println("Key: " + key);
} } }

OUTPUT:

RESULT:

21
Exp No : 2 (B) DATE : 20/08/2024
CRYPTOGRAPHIC ATTACK-AFFINE CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

package attackaffine;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Affineattack {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the Plaintext Sentence: ");
String plaintext = scanner.nextLine().toUpperCase().replaceAll("[^A-Z]", "");
System.out.print("Enter the Ciphertext Sentence: ");
String ciphertext = scanner.nextLine().toUpperCase().replaceAll("[^A-Z]", "");

if (plaintext.length() != ciphertext.length()) {
System.out.println("Plaintext and Ciphertext must have the same length.");

22
 return;
}
Map<Character, Character> charMap = new HashMap<>();
for (int i = 0; i < plaintext.length(); i++) {
char p = plaintext.charAt(i);
char c = ciphertext.charAt(i);
if (charMap.containsKey(p) && charMap.get(p) != c) {
System.out.println("Inconsistent mappings detected.");
return;
}
charMap.put(p, c);
}
if (charMap.size() < 2) {
System.out.println("Not enough unique mappings to determine the key.");
return;
}
Character[] keys = charMap.keySet().toArray(new Character[0]);
char p1 = keys[0];
char p2 = keys[1];
char c1 = charMap.get(p1);
char c2 = charMap.get(p2);

int P1 = p1 - 'A';
int C1 = c1 - 'A';
int P2 = p2 - 'A';
int C2 = c2 - 'A';
int[] keyPair = findKeyPair(P1, C1, P2, C2);
if (keyPair != null) {
System.out.println("The key pair (a, b) is: (" + keyPair[0] + ", " + keyPair[1] + ")");
} else {
System.out.println("Could not determine a valid key pair.");
}
}
private static int[] findKeyPair(int P1, int C1, int P2, int C2) {
int mod = 26;
int P1P2Diff = (P1 - P2 + mod) % mod;
int inverse = multiplicativeInverse(P1P2Diff, mod);

if (inverse == -1) {
return null;
}
int a = (inverse * (C1 - C2 + mod)) % mod;
int b = (C1 - a * P1 + mod) % mod;

return new int[]{a, b};

}
private static int multiplicativeInverse(int a, int mod) {
for (int x = 1; x < mod; x++) {
if ((a * x) % mod == 1) {
return x;

23
 }
}
return -1;
}
}

OUTPUT:

RESULT:

24
Exp No : 2 (C) DATE : 20/08/2024
CRYPTOGRAPHIC ATTACK- HILL CIPHER

AIM:

ALGORITHM:

SOURCE CODE:

package attackhill;
import java.util.Scanner;

public class Attackhill {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
String letters = "abcdefghijklmnopqrstuvwxyz";
System.out.println("Enter the plaintext:");
String plaintext = scanner.nextLine().toLowerCase();
System.out.println("Enter the ciphertext:");
String ciphertext = scanner.nextLine().toLowerCase();
System.out.println("Enter matrix dimension M:");
int m = scanner.nextInt();

if (plaintext.length() % m != 0 || ciphertext.length() % m != 0) {
System.out.println("Plaintext and ciphertext lengths must be multiples of the matrix
dimension.");
return;
}

25
 int[][] plainMatrix = createMatrixFromText(plaintext, m, letters);
int[][] cipherMatrix = createMatrixFromText(ciphertext, m, letters);
int[][] inversePlainMatrix = inverseMatrix(plainMatrix, m, letters.length());
int[][] keyMatrix = multiplyMatrix(m, m, inversePlainMatrix, m, m, cipherMatrix);

System.out.println("Key Matrix:");
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
System.out.print(keyMatrix[i][j] + " ");
}
System.out.println();
}
}
private static int[][] createMatrixFromText(String text, int m, String letters) {
int n = text.length() / m;
int[][] matrix = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = letters.indexOf(text.charAt(i * m + j));
}
}
return matrix;
}
private static int[][] inverseMatrix(int[][] mat, int m, int mod) {
int det = determinantOfMatrix(mat, m);
det = mod(det, mod);
int inverseDet = modularInverse(det, mod);
int[][] adj = new int[m][m];
adjoint(mat, adj, m);
int[][] inverseMatrix = new int[m][m];
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
inverseMatrix[i][j] = mod(adj[i][j] * inverseDet, mod);
}
}
return inverseMatrix;
}

private static void adjoint(int[][] mat, int[][] adj, int n) {

if (n == 1) {
adj[0][0] = 1;
return;
}

int[][] temp = new int[n][n];

int sign;

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

for (int j = 0; j < n; j++) {
getCofactor(mat, temp, i, j, n);

26
 sign = ((i + j) % 2 == 0) ? 1 : -1;
adj[j][i] = sign * determinantOfMatrix(temp, n - 1);
}
}
}

private static void getCofactor(int[][] mat, int[][] temp, int p, int q, int n) {
int i = 0, j = 0;

for (int row = 0; row < n; row++) {

for (int col = 0; col < n; col++) {
if (row != p && col != q) {
temp[i][j++] = mat[row][col];
if (j == n - 1) {
j = 0;
i++;
}
}
}
}
}

private static int determinantOfMatrix(int[][] mat, int n) {

int D = 0;
if (n == 1) {
return mat[0][0];
}

int[][] temp = new int[n - 1][n - 1];

int sign = 1;

for (int f = 0; f < n; f++) {

getCofactor(mat, temp, 0, f, n);
D += sign * mat[0][f] * determinantOfMatrix(temp, n - 1);
sign = -sign;
}

return D;
}

private static int modularInverse(int a, int m) {

for (int x = 1; x < m; x++) {
if ((a * x) % m == 1) {
return x;
}
}
return 1;
}

private static int mod(int x, int n) {

27
 int r = x % n;
if (r < 0) {
r += n;
}
return r;
}

private static int[][] multiplyMatrix(int row1, int col1, int[][] A, int row2, int col2, int[][] B) {
int[][] C = new int[row1][col2];
for (int i = 0; i < row1; i++) {
for (int j = 0; j < col2; j++) {
for (int k = 0; k < col1; k++) {
C[i][j] += A[i][k] * B[k][j];
}
C[i][j] = mod(C[i][j], 26);
}
}
return C;
}
}

OUTPUT:

RESULT:

28