1. Implement the following SUBSTITUTION & TRANSPOSITION TECHNIQUES.
(a). Caesar Cipher
import [Link];
public class CaesarCipherExample
{
public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
public static String encryptData(String inputStr, int shiftKey)
{
inputStr = [Link]();
String encryptStr = "";
for (int i = 0; i < [Link](); i++)
{
int pos = [Link]([Link](i));
int encryptPos = (shiftKey + pos) % 26;
char encryptChar = [Link](encryptPos);
encryptStr += encryptChar;
}
return encryptStr;
}
public static String decryptData(String inputStr, int shiftKey)
{
inputStr = [Link]();
String decryptStr = "";
for (int i = 0; i < [Link](); i++)
{
int pos = [Link]([Link](i));
int decryptPos = (pos - shiftKey) % 26;
if (decryptPos < 0){
decryptPos = [Link]() + decryptPos;
}
char decryptChar = [Link](decryptPos);
decryptStr += decryptChar;
}
return decryptStr;
}
public static void main(String[] args)
{
Scanner sc = new Scanner([Link]);
[Link]("Enter a string for encryption using Caesar
Cipher: ");
String inputStr = [Link]();
[Link]("Enter the value by which each character in
the plaintext message gets shifted: ");
int shiftKey = [Link]([Link]());
[Link]("Encrypted Data ===> "+encryptData(inputStr,
shiftKey));
[Link]("Decrypted Data ===>
"+decryptData(encryptData(inputStr, shiftKey), shiftKey));
[Link]();
}
}
(b) Playfair Cipher
import [Link];
import [Link];
public class PlayfairCipher
{
private int length = 0;
private String [][] table;
public static void main(String args[])
{
PlayfairCipher pf = new PlayfairCipher();
}
private PlayfairCipher()
{
[Link]("Enter the key for playfair cipher: ");
Scanner sc = new Scanner([Link]);
String key = parseString(sc);
while([Link](""))
key = parseString(sc);
table = [Link](key);
[Link]("Enter the plaintext to be encipher: ");
String input = parseString(sc);
while([Link](""))
input = parseString(sc);
String output = cipher(input);
String decodedOutput = decode(output);
[Link](table);
[Link](output,decodedOutput);
}
private String parseString(Scanner sc)
{
String parse = [Link]();
parse = [Link]();
parse = [Link]("[^A-Z]", "");
parse = [Link]("J", "I");
return parse;
}
private String[][] cipherTable(String key)
{
String[][] playfairTable = new String[5][5];
String keyString = key + "ABCDEFGHIKLMNOPQRSTUVWXYZ";
for(int i = 0; i < 5; i++)
for(int j = 0; j < 5; j++)
playfairTable[i][j] = "";
for(int k = 0; k < [Link](); k++)
{
boolean repeat = false;
boolean used = false;
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
{
if(playfairTable[i][j].equals("" + [Link](k)))
{
repeat = true;
}
else if(playfairTable[i][j].equals("") && !repeat && !used)
{
playfairTable[i][j] = "" + [Link](k);
used = true;
}
}
}
}
return playfairTable;
}
private String cipher(String in)
{
length = (int) [Link]() / 2 + [Link]() % 2;
for(int i = 0; i < (length - 1); i++)
{
if([Link](2 * i) == [Link](2 * i + 1))
{
in = new StringBuffer(in).insert(2 * i + 1, 'X').toString();
length = (int) [Link]() / 2 + [Link]() % 2;
}
}
String[] digraph = new String[length];
for(int j = 0; j < length ; j++)
{
if(j == (length - 1) && [Link]() / 2 == (length - 1))
in = in + "X";
digraph[j] = [Link](2 * j) +""+ [Link](2 * j + 1);
}
String out = "";
String[] encDigraphs = new String[length];
encDigraphs = encodeDigraph(digraph);
for(int k = 0; k < length; k++)
out = out + encDigraphs[k];
return out;
}
private String[] encodeDigraph(String di[])
{
String[] encipher = new String[length];
for(int i = 0; i < length; i++)
{
char a = di[i].charAt(0);
char b = di[i].charAt(1);
int r1 = (int) getPoint(a).getX();
int r2 = (int) getPoint(b).getX();
int c1 = (int) getPoint(a).getY();
int c2 = (int) getPoint(b).getY();
if(r1 == r2)
{
c1 = (c1 + 1) % 5;
c2 = (c2 + 1) % 5;
}
else if(c1 == c2)
{
r1 = (r1 + 1) % 5;
r2 = (r2 + 1) % 5;
}
else
{
int temp = c1;
c1 = c2;
c2 = temp;
}
encipher[i] = table[r1][c1] + "" + table[r2][c2];
}
return encipher;
}
private String decode(String out)
{
String decoded = "";
for(int i = 0; i < [Link]() / 2; i++)
{
char a = [Link](2*i);
char b = [Link](2*i+1);
int r1 = (int) getPoint(a).getX();
int r2 = (int) getPoint(b).getX();
int c1 = (int) getPoint(a).getY();
int c2 = (int) getPoint(b).getY();
if(r1 == r2)
{
c1 = (c1 + 4) % 5;
c2 = (c2 + 4) % 5;
}
else if(c1 == c2)
{
r1 = (r1 + 4) % 5;
r2 = (r2 + 4) % 5;
}
else
{
int temp = c1;
c1 = c2;
c2 = temp;
}
decoded = decoded + table[r1][c1] + table[r2][c2];
}
return decoded;
}
private Point getPoint(char c)
{
Point pt = new Point(0,0);
for(int i = 0; i < 5; i++)
for(int j = 0; j < 5; j++)
if(c == table[i][j].charAt(0))
pt = new Point(i,j);
return pt;
}
private void keyTable(String[][] printTable)
{
[Link]("Playfair Cipher Key Matrix: ");
[Link]();
for(int i = 0; i < 5; i++) {
for(int j = 0; j < 5; j++)
{
[Link](printTable[i][j]+" ");
}
[Link]();
}
[Link]();
}
private void printResults(String encipher, String dec)
{
[Link]("Encrypted Message: ");
[Link](encipher);
[Link]();
[Link]("Decrypted Message: ");
[Link](dec);
}
}
(c) Hill Cipher
import [Link];
import [Link];
public class HillCipherExample {
private static int[][] getKeyMatrix() {
Scanner sc = new Scanner([Link]);
[Link]("Enter key matrix:");
String key = [Link]();
double sq = [Link]([Link]());
if (sq != (long) sq) {
[Link]("Cannot Form a square matrix");
}
int len = (int) sq;
int[][] keyMatrix = new int[len][len];
int k = 0;
for (int i = 0; i < len; i++)
{
for (int j = 0; j < len; j++)
{
keyMatrix[i][j] = ((int) [Link](k)) - 97;
k++;
}
}
return keyMatrix;
}
private static void isValidMatrix(int[][] keyMatrix) {
int det = keyMatrix[0][0] * keyMatrix[1][1] - keyMatrix[0][1] *
keyMatrix[1][0];
if(det == 0) {
throw new [Link]("Det equals to zero, invalid key
matrix!");
}
}
private static void isValidReverseMatrix(int[][] keyMatrix,
int[][] reverseMatrix) {
int[][] product = new int[2][2];
product[0][0] = (keyMatrix[0][0]*reverseMatrix[0][0] +
keyMatrix[0][1] * reverseMatrix[1][0]) % 26;
product[0][1] = (keyMatrix[0][0]*reverseMatrix[0][1] +
keyMatrix[0][1] * reverseMatrix[1][1]) % 26;
product[1][0] = (keyMatrix[1][0]*reverseMatrix[0][0] +
keyMatrix[1][1] * reverseMatrix[1][0]) % 26;
product[1][1] = (keyMatrix[1][0]*reverseMatrix[0][1] +
keyMatrix[1][1] * reverseMatrix[1][1]) % 26;
if(product[0][0] != 1 || product[0][1] != 0 || product[1][0] !=
0 || product[1][1] != 1) {
throw new [Link]("Invalid reverse matrix found!");
}
}
private static int[][] reverseMatrix(int[][] keyMatrix) {
int detmod26 = (keyMatrix[0][0] * keyMatrix[1][1] -
keyMatrix[0][1] * keyMatrix[1][0]) % 26; // Calc det
int factor;
int[][] reverseMatrix = new int[2][2];
for(factor=1; factor < 26; factor++)
{
if((detmod26 * factor) % 26 == 1)
{
break;
}
}
reverseMatrix[0][0] = keyMatrix[1][1] * factor % 26;
reverseMatrix[0][1] = (26 - keyMatrix[0][1]) * factor % 26;
reverseMatrix[1][0] = (26 - keyMatrix[1][0]) * factor % 26;
reverseMatrix[1][1] = keyMatrix[0][0] * factor % 26;
return reverseMatrix;
}
private static void echoResult(String label, int adder,
ArrayList<Integer> phrase) {
int i;
[Link](label);
for(i=0; i < [Link](); i += 2) {
[Link]([Link]([Link](i) + (64 +
adder)));
[Link]([Link]([Link](i+1) + (64 +
adder)));
if(i+2 <[Link]()) {
[Link]("-");
}
}
[Link]();
}
public static void encrypt(String phrase, boolean alphaZero)
{
int i;
int adder = alphaZero ? 1 : 0;
int[][] keyMatrix;
ArrayList<Integer> phraseToNum = new ArrayList<>();
ArrayList<Integer> phraseEncoded = new ArrayList<>();
phrase = [Link]("[^a-zA-Z]","").toUpperCase();
if([Link]() % 2 == 1) {
phrase += "Q";
}
keyMatrix = getKeyMatrix();
isValidMatrix(keyMatrix);
for(i=0; i < [Link](); i++) {
[Link]([Link](i) - (64 + adder));
}
for(i=0; i < [Link](); i += 2) {
int x = (keyMatrix[0][0] * [Link](i) +
keyMatrix[0][1] * [Link](i+1)) % 26;
int y = (keyMatrix[1][0] * [Link](i) +
keyMatrix[1][1] * [Link](i+1)) % 26;
[Link](alphaZero ? x : (x == 0 ? 26 : x ));
[Link](alphaZero ? y : (y == 0 ? 26 : y ));
}
echoResult("Encoded phrase: ", adder, phraseEncoded);
}
public static void decrypt(String phrase, boolean alphaZero)
{
int i, adder = alphaZero ? 1 : 0;
int[][] keyMatrix, revKeyMatrix;
ArrayList<Integer> phraseToNum = new ArrayList<>();
ArrayList<Integer> phraseDecoded = new ArrayList<>();
phrase = [Link]("[^a-zA-Z]","").toUpperCase();
keyMatrix = getKeyMatrix();
isValidMatrix(keyMatrix);
for(i=0; i < [Link](); i++) {
[Link]([Link](i) - (64 + adder));
}
revKeyMatrix = reverseMatrix(keyMatrix);
isValidReverseMatrix(keyMatrix, revKeyMatrix);
for(i=0; i < [Link](); i += 2) {
[Link]((revKeyMatrix[0][0] * [Link](i)
+ revKeyMatrix[0][1] * [Link](i+1)) % 26);
[Link]((revKeyMatrix[1][0] * [Link](i)
+ revKeyMatrix[1][1] * [Link](i+1)) % 26);
}
echoResult("Decoded phrase: ", adder, phraseDecoded);
}
public static void main(String[] args) {
String opt, phrase;
byte[] p;
Scanner sc = new Scanner([Link]);
[Link]("Hill Cipher Implementation (2x2)");
[Link]("-------------------------");
[Link]("1. Encrypt text (A=0,B=1,...Z=25)");
[Link]("2. Decrypt text (A=0,B=1,...Z=25)");
[Link]("3. Encrypt text (A=1,B=2,...Z=26)");
[Link]("4. Decrypt text (A=1,B=2,...Z=26)");
[Link]();
[Link]("Type any other character to exit");
[Link]();
[Link]("Select your choice: ");
opt = [Link]();
switch (opt)
{
case "1":
[Link]("Enter phrase to encrypt: ");
phrase = [Link]();
encrypt(phrase, true);
break;
case "2":
[Link]("Enter phrase to decrypt: ");
phrase = [Link]();
decrypt(phrase, true);
break;
case "3":
[Link]("Enter phrase to encrypt: ");
phrase = [Link]();
encrypt(phrase, false);
break;
case "4":
[Link]("Enter phrase to decrypt: ");
phrase = [Link]();
decrypt(phrase, false);
break;
}
}
}
(d).Rail fence
import [Link].*;
class RailFenceBasic{
int depth;
String Encryption(String plainText,int depth)throws Exception
{
int r=depth,len=[Link]();
int c=len/depth;
char mat[][]=new char[r][c];
int k=0;
String cipherText="";
for(int i=0;i< c;i++)
{
for(int j=0;j< r;j++)
{
if(k!=len)
mat[j][i]=[Link](k++);
else
mat[j][i]='X';
}
}
for(int i=0;i< r;i++)
{
for(int j=0;j< c;j++)
{
cipherText+=mat[i][j];
}
}
return cipherText;
}
String Decryption(String cipherText,int depth)throws Exception
{
int r=depth,len=[Link]();
int c=len/depth;
char mat[][]=new char[r][c];
int k=0;
String plainText="";
for(int i=0;i< r;i++)
{
for(int j=0;j< c;j++)
{
mat[i][j]=[Link](k++);
}
}
for(int i=0;i< c;i++)
{
for(int j=0;j< r;j++)
{
plainText+=mat[j][i];
}
}
return plainText;
}
}
class RailFence{
public static void main(String args[])throws Exception
{
RailFenceBasic rf=new RailFenceBasic();
Scanner scn=new Scanner([Link]);
int depth;
String plainText,cipherText,decryptedText;
[Link]("Enter plain text:");
plainText=[Link]();
[Link]("Enter depth for Encryption:");
depth=[Link]();
cipherText=[Link](plainText,depth);
[Link]("Encrypted text is:\n"+cipherText);
decryptedText=[Link](cipherText, depth);
[Link]("Decrypted text is:\n"+decryptedText);
}
}
Output.
