ASSIGNMENT-1

CSE-1007: Introduction to Cryptography

By K.Vamsi krishna(18BCN7125)
FACULTY : PROF BALU LAXMAN
PARNE SLOT : C1

School of Computer Science & Engineering

VIT-AP UNIVERSITY, INAVOLU, AMARAVATI
OCTOBER, 2019
1. Write a program that can perform a letter frequency attack on an additive cipher

without human intervention. Your program should produce possible plaintexts in rough

order of likelihood. It would be good if your user interface allowed the user to specify

“give me the top 10 possible plaintexts”.

CODE:

public class One

public static void main(String args[])

String s

="XLILSYWIMWRSAJSVWEPIJSVVQMPPMSRHSPPEVWMXMWASVXLQSVILYVV

CFIJSVIXLIWIPPIVVIGIMZIWQSVISJJIVW";

Frequency obj = new Frequency();

obj.main(s);

char[] constC = {'E','T','A','O','I','N','S','H','R','D'};

for(int i = 0 ; i < s.length() && i<10 ; i++)

int key = mod(obj.alpha[0] - constC[i]) ;

System.out.print("KEY : " + key + " ");

for(int j = 0 ; j < s.length() ; j++)

int c = (s.charAt(j) - 65);

char t = (char)(mod((c - key)) + 65);

System.out.print(t);

System.out.println();

public static int mod(int n)

if(n < 0)

return(n+26)%26;

else

return n%26;
}

class Frequency

double[] frequencyDistribution;

char[] alpha;

public void main(String s)

//Finding the unique variable

char[] US = new char[s.length()];

int t = 0 ;

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

char c = s.charAt(i);

boolean found = false;

for(int j = 0 ; j < US.length; j++)

{

if(c == US[j])

found = true;

if(found)

continue;

else

US[t] = c ;

t++;

//finding frequency

double[] numerical = new double[US.length];

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

{
for(int j = 0 ; j < s.length() ; j++)

if(s.charAt(j) == US[i])

numerical[i]++;

for(double x : numerical)

x = (x / s.length())*100;

bubbleSort(numerical , US);

frequencyDistribution = numerical;

alpha = US;

void bubbleSort(double arr[] , char array[])

int n = arr.length;

for (int i = 0; i < n-1; i++)

for (int j = 0; j < n-i-1; j++)

if (arr[j] < arr[j+1])

// swap arr[j+1] and arr[i]

double temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

char t = array[j];

array[j] = array[j+1];

array[j+1] = t;

OUTPUT:
2. Write a program that can perform a letter frequency attack on any monoalphabetic

substitution cipher without human intervention. Your program should produce possible

plaintexts in rough order of likelihood. It would be good if your user interface allowed

the user to specify “give me the top 10 possible plaintexts”.

CODE:

public class Two

public static void main(String agrs[])

String s

="BZSZYMQSKQNYIDYFQARSDYFFCKRRKYNHYRRAFQKBKQIYFBZCYFSZMFF

ELSDYFSBZSQSRRSFFSWSKXSQCYFSYDDSFQ";

Frequency2 obj = new Frequency2();

obj.main(s);

char[] constC = {'E','T','A','O','I','N','S','H','R','D'};

for(int i = 0 ; i < s.length() && i<10 ; i++)

int key = mod(obj.alpha[0] - constC[i]) ;

int invkey;

if(found(key))

invkey = inverse(26 ,key);

else

continue;

System.out.print("KEY : " + key + " ");

for(int j = 0 ; j < s.length() ; j++)

int c = (s.charAt(j) - 65);

char t = (char)(mod(mod(c*invkey)) + 65);

System.out.print(t);

}
System.out.println();

public static int mod(int n)

if(n < 0)

return(n+26)%26;

else

return n%26;

public static boolean found(int k)

int key[] = {1,3,5,7,9,11,15,17,19,21,23,25};

for(int x : key)

if(x == k)
return true;

return false;

public static int inverse(int a , int b)

int s1 = 1 ;

int s2 = 0 ;

int t1 = 0 ;

int t2 = 1 ;

int q = a/b;

int r = a%b ;

int t = 0 ;

while(r > 0)

a = b;

b = r; t = s1 ;
s1 = s2; s2 = t - q*s2; t = t1 ;

t1 = t2; t2 = t - q*t2;

r = a %b;

q = a /b ;

return t2;

class Frequency2

double[] frequencyDistribution;

char[] alpha;

public void main(String s)

//Finding the uquine variable

char[] US = new char[s.length()];

int t = 0 ;
for(int i = 0 ; i < s.length() ; i++)

char c = s.charAt(i);

boolean found = false;

for(int j = 0 ; j < US.length; j++)

if(c == US[j])

found = true;

if(found)

continue;

else

US[t] = c ;

t++;

}
}

//finding frequency

double[] numerical = new double[US.length];

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

for(int j = 0 ; j < s.length() ; j++)

if(s.charAt(j) == US[i])

numerical[i]++;

for(double x : numerical)

x = (x / s.length())*100;

bubbleSort(numerical , US);

frequencyDistribution = numerical;

alpha = US;
}

void bubbleSort(double arr[] , char array[])

int n = arr.length;

for (int i = 0; i < n-1; i++)

for (int j = 0; j < n-i-1; j++)

if (arr[j] < arr[j+1])

// swap arr[j+1] and arr[i]

double temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

char t = array[j];

array[j] = array[j+1];

array[j+1] = t;

}
}

OUTPUT:

3. Create software that can encrypt and decrypt using a 3 x 3 Hill cipher.

CODE:

import java.io.*;

import java.util.*;

public class HillCipher

int keymatrix[][];

int linematrix[];

int resultmatrix[];
public void divide(String temp, int s)

while (temp.length() > s)

String sub = temp.substring(0, s);

temp = temp.substring(s, temp.length());

perform(sub);

if (temp.length() == s)

perform(temp);

else if (temp.length() < s)

for (int i = temp.length(); i < s; i++)

temp = temp + 'x';

perform(temp);

}
public void perform(String line)

linetomatrix(line);

linemultiplykey(line.length());

result(line.length());

public void keytomatrix(String key, int len)

keymatrix = new int[len][len];

int c = 0;

for (int i = 0; i < len; i++)

for (int j = 0; j < len; j++)

keymatrix[i][j] = ((int) key.charAt(c)) - 97;

 c++;

public void linetomatrix(String line)

linematrix = new int[line.length()];

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

linematrix[i] = ((int) line.charAt(i)) - 97;

public void linemultiplykey(int len)

resultmatrix = new int[len];

 for (int i = 0; i < len; i++)

for (int j = 0; j < len; j++)

resultmatrix[i] += keymatrix[i][j] * linematrix[j];

resultmatrix[i] %= 26;

public void result(int len)

String result = "";

for (int i = 0; i < len; i++)

result += (char) (resultmatrix[i] + 97);

}
 System.out.print(result);

public boolean check(String key, int len)

keytomatrix(key, len);

int d = determinant(keymatrix, len);

d = d % 26;

if (d == 0)

System.out.println("Invalid key!!! Key is not invertible because determinant=0...");

return false;

else if (d % 2 == 0 || d % 13 == 0)

System.out.println("Invalid key!!! Key is not invertible because determinant has

common factor with 26...");

 return false;

else

return true;

public int determinant(int A[][], int N)

int res;

if (N == 1)

res = A[0][0];

else if (N == 2)

res = A[0][0] * A[1][1] - A[1][0] * A[0][1];

}
else

res = 0;

for (int j1 = 0; j1 < N; j1++)

int m[][] = new int[N - 1][N - 1];

for (int i = 1; i < N; i++)

int j2 = 0;

for (int j = 0; j < N; j++)

if (j == j1)

continue;

m[i - 1][j2] = A[i][j];

j2++;

}
 res += Math.pow(-1.0, 1.0 + j1 + 1.0) * A[0][j1]* determinant(m, N - 1);

return res;

public void cofact(int num[][], int f)

int b[][], fac[][];

b = new int[f][f];

fac = new int[f][f];

int p, q, m, n, i, j;

for (q = 0; q < f; q++)

for (p = 0; p < f; p++)

m = 0;
n = 0;

for (i = 0; i < f; i++)

for (j = 0; j < f; j++)

b[i][j] = 0;

if (i != q && j != p)

b[m][n] = num[i][j];

if (n < (f - 2))

n++;

else

n = 0;

m++;

}
 }

fac[q][p] = (int) Math.pow(-1, q + p) * determinant(b, f - 1);

trans(fac, f);

void trans(int fac[][], int r)

int i, j;

int b[][], inv[][];

b = new int[r][r];

inv = new int[r][r];

int d = determinant(keymatrix, r);

int mi = mi(d % 26);

mi %= 26;
if (mi < 0)

mi += 26;

for (i = 0; i < r; i++)

for (j = 0; j < r; j++)

b[i][j] = fac[j][i];

for (i = 0; i < r; i++)

for (j = 0; j < r; j++)

inv[i][j] = b[i][j] % 26;

if (inv[i][j] < 0)

inv[i][j] += 26;

inv[i][j] *= mi;
 inv[i][j] %= 26;

System.out.println("\nInverse key:");

matrixtoinvkey(inv, r);

public int mi(int d)

int q, r1, r2, r, t1, t2, t;

r1 = 26;

r2 = d;

t1 = 0;

t2 = 1;

while (r1 != 1 && r2 != 0)

q = r1 / r2;
 r = r1 % r2;

t = t1 - (t2 * q);

r1 = r2;

r2 = r;

t1 = t2;

t2 = t;

return (t1 + t2);

public void matrixtoinvkey(int inv[][], int n)

String invkey = "";

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

for (int j = 0; j < n; j++)

{
 invkey += (char) (inv[i][j] + 97);

System.out.print(invkey);

public static void main(String args[]) throws IOException

HillCipher obj = new HillCipher();

Scanner sc=new Scanner(System.in);

int choice;

System.out.println("Menu:\n1: Encryption\n2: Decryption");

choice = sc.nextInt();

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

String line = sc.next();

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

String key = sc.next();

 double sq = Math.sqrt(key.length());

if (sq != (long) sq)

System.out.println("Invalid key length!!! Does not form a square matrix...");

else

int s = (int) sq;

if (obj.check(key, s))

System.out.println("Result:");

obj.divide(line, s);

obj.cofact(obj.keymatrix, s);

OUTPUT:
4. Create a software that can encrypt and decrypt message using Playfair Cipher with

specific key (You can consider any key of your choice). If you can implement for the

generalized key means user can input the key at run time then more weightage will be

given for such solution.

CODE:

import java.util.*;

public class Playfair

String KeyWord;

String Key;

char matrix_arr[][] = new char[5][5];

public void setKey(String k)

 {

String keyfill="";

boolean flag = false;

keyfill = keyfill + k.charAt(0);

for (int i = 1; i < k.length(); i++)

for (int j = 0; j < keyfill.length(); j++)

if (k.charAt(i) == keyfill.charAt(j))

flag = true;

if (flag == false)

keyfill = keyfill + k.charAt(i);

flag = false;

}
 KeyWord = keyfill;

public void KeyGen()

boolean flag = true;

char current;

Key = KeyWord;

for (int i = 0; i < 26; i++)

current = (char) (i + 97);

if (current == 'j')

continue;

for (int j = 0; j < KeyWord.length(); j++)

if (current == KeyWord.charAt(j))

{
 flag = false;

break;

if (flag)

Key = Key + current;

flag = true;

System.out.println(Key);

matrix();

public void matrix()

int counter = 0;

for (int i = 0; i < 5; i++)

 {

for (int j = 0; j < 5; j++)

matrix_arr[i][j] = Key.charAt(counter);

System.out.print(matrix_arr[i][j] + " ");

counter++;

System.out.println();

public String format(String old_text)

int i;

String text="";

int len = old_text.length();

for (int tmp = 0; tmp < len; tmp++)

{

if (old_text.charAt(tmp) == 'j')

text = text + 'i';

else

text = text + old_text.charAt(tmp);

len = text.length();

for (i=0;i<len;i=i+2)

if (text.charAt(i+1) == text.charAt(i))

text = text.substring(0,i+1) +'x'+text.substring(i+1);//nahi samjha

return text;
 }

public String[] Divid2Pairs(String new_string)

String Original = format(new_string);

int size = Original.length();

if (size % 2 != 0)

size++;

Original = Original + 'x';

String x[] = new String[size/2];

int counter = 0;

for (int i = 0;i<size/2;i++)

x[i] = Original.substring(counter, counter + 2);

counter = counter + 2;
 }

return x;

public int[] GetDiminsions(char letter)

int[] key = new int[2];

if (letter == 'j')

letter = 'i';

for (int i = 0; i < 5; i++)

for (int j = 0; j < 5; j++)

if (matrix_arr[i][j] == letter)

key[0] = i;

key[1] = j;
 break;

return key;

public String encryptMessage(String Source)

String src_arr[] = Divid2Pairs(Source);

String Code = new String();

char one;

char two;

int part1[] = new int[2];

int part2[] = new int[2];

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

{
one = src_arr[i].charAt(0);

two = src_arr[i].charAt(1);

part1 = GetDiminsions(one);

part2 = GetDiminsions(two);

if (part1[0] == part2[0])

if (part1[1] < 4)

part1[1]++;

else

part1[1] = 0;

if (part2[1] < 4)

part2[1]++;

else

part2[1] = 0;

else if (part1[1] == part2[1])

{
 if (part1[0] < 4)

part1[0]++;

else

part1[0] = 0;

if (part2[0] < 4)

part2[0]++;

else

part2[0] = 0;

else

int temp = part1[1];

part1[1] = part2[1];

part2[1] = temp;

Code = Code + matrix_arr[part1[0]][part1[1]]

+ matrix_arr[part2[0]][part2[1]];
 }

return Code;

public String decryptMessage(String Code)

String Original = new String();

String src_arr[] = Divid2Pairs(Code);

char one;

char two;

int part1[] = new int[2];

int part2[] = new int[2];

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

one = src_arr[i].charAt(0);

two = src_arr[i].charAt(1);

part1 = GetDiminsions(one);

part2 = GetDiminsions(two);
if (part1[0] == part2[0])

if (part1[1] > 0)

part1[1]--;

else

part1[1] = 4;

if (part2[1] > 0)

part2[1]--;

else

part2[1] = 4;

else if (part1[1] == part2[1])

if (part1[0] > 0)

part1[0]--;

else

part1[0] = 4;
 if (part2[0] > 0)

part2[0]--;

else

part2[0] = 4;

else

int temp = part1[1];

part1[1] = part2[1];

part2[1] = temp;

Original = Original + matrix_arr[part1[0]][part1[1]]

+ matrix_arr[part2[0]][part2[1]];

return Original;

}
public static void main(String[] args)

Playfair x = new Playfair();

Scanner sc = new Scanner(System.in);

System.out.println("Enter a keyword:");

String keyword = sc.next();

x.setKey(keyword);

x.KeyGen();

System.out.println("Enter word to encrypt: ");

String key_input = sc.next();

if (key_input.length() % 2 == 0)

System.out.println("Encryption: " + x.encryptMessage(key_input));

else

System.out.println("Please Enter The Bogus Character");

 String t=sc.next();

key_input=key_input+t;

System.out.println("Encryption: " + x.encryptMessage(key_input));

System.out.println("After Decryption :

"+x.decryptMessage(x.encryptMessage(key_input)));

OUTPUT:
5. Write a program to implement Vigenere Cipher. You have to write a method for both

encryption and decryption of the message.

CODE:

import java.util.*;

public class Vignerre

public static String generatekey(String str, String key)

int x = str.length();

for (int i = 0;key.length() &lt; str.length() ; i++)

if (x ==

i){ i = 0;

key+=(key.charAt(i));
}

return key;

static String encryption(String str, String key)

String ct=&quot;&quot;;

for (int i = 0; i &lt; str.length(); i++)

int x = (str.charAt(i) + key.charAt(i)) %26;

x =x+&#39;A&#39;;//bas ek step unknown hai..

ct=ct+(char)(x);

return ct;

static String decryption(String cipher_text, String key)

{

String original=&quot;&quot;;

for (int i = 0 ; i &lt; cipher_text.length() &amp;&amp; i &lt; key.length(); i++)

int x = (cipher_text.charAt(i) - key.charAt(i) + 26) %26;

x =x+ &#39;A&#39;;

original=original+(char)(x);

return original;

public static void main(String[] args)

Scanner sc=new Scanner(System.in);

System.out.println(&quot;Please Enter a message to Encrypt (in Capitals)&quot;);

String str = sc.next();

System.out.println(&quot;Please Enter a key to start the process (in Capitals)&quot;);

String keyword = sc.next();

String key = generatekey(str, keyword);

System.out.println(&quot;Ciphertext : &quot;+encryption(str,key));

System.out.println(&quot;Original Text : &quot; +decryption(encryption(str,key), key));

OUTPUT:

6. Write a program for finding multiplicative inverse using Extended Euclidean

Algorithm.

CODE:

import java.io.*;

import java.util.*;

class Inverse
{

public static void main(String args[])

Scanner sc=new Scanner(System.in);

int r1,r2,r=0,q,t1=0,t2=1,t,n,inv;

System.out.println("Enter the number whose multiplicative inverse you want to find");

r1=sc.nextInt();

System.out.println("Enter the range");

r2=sc.nextInt();

n=r2;

r=r1%r2;

while(r>0)

q=r1/r2;

r=r1%r2;

t=t1-(q*t2);

r1=r2;
 r2=r;

t1=t2;

t2=t;

inv=t1;

if(r1==1)

if(inv>0)

System.out.println("The inverse of the entered number is: "+inv);

else

inv=inv+n;

System.out.println("The inverse of the entered number is: "+inv);

else

System.out.println("The inverse does not exist");

 }

output:

7. Write a program to compute the multiplication of two polynomial equation in GF(28

). Consider the given irreducible polynomial equation is x8 + x4 + x3 + x + 1.

CODE:

import java.util.*;

class Poly_Multiplication

static int[] multiply(int A[], int B[],

int m, int n)
 {

int[] prod = new int[m + n - 1];

// Initialize the porduct polynomial

for (int i = 0; i < m + n - 1; i++)

prod[i] = 0;

// Multiply two polynomials term by term

// Take ever term of first polynomial

for (int i = 0; i < m; i++)

// Multiply the current term of first polynomial

// with every term of second polynomial.

for (int j = 0; j < n; j++)

prod[i + j] += A[i] * B[j];

}
 }

return prod;

static void printPoly(int poly[], int n)

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

System.out.print(poly[i]);

if (i != 0)

System.out.print("x^" + i);

if (i != n - 1)

System.out.print(" + ");

}
 System.out.println();

public static void main(String[] args)

// The following array represents

// polynomial 5 + 10x^2 + 6x^3

int A[] = {5, 0, 10, 6};

// The following array represents

// polynomial 1 + 2x + 4x^2

int B[] = {1, 2, 4};

int m = A.length;

int n = B.length;

System.out.println("First polynomial is n");

printPoly(A, m);

System.out.println("Second polynomial is n");

printPoly(B, n);

int[] prod = multiply(A, B, m, n);

 System.out.println("Product polynomial is n");

printPoly(prod, m + n - 1);

OUTPUT:

8. AES

CODE:

) import java.util.*;

public class AES{

String[] KeyExpansion(String

key){ String Rcon1 =

"10000000"; String Rcon2 =

"00110000";

StringBuilder w0 = new StringBuilder(key.substring(0,8));

StringBuilder w1 = new StringBuilder(key.substring(8));

String XORResult1 = XOR(w0.toString(),Rcon1);

String NibbleResult1 = SubNibble(w1.toString());

String XORResult2 = XOR(XORResult1,NibbleResult1);

StringBuilder w2 = new StringBuilder(XORResult2);

String w3 = XOR(w2.toString(),w1.toString());

String key1 = w2.toString()+w3;

String XORResult3 = XOR(w2.toString(),Rcon2);

String NibbleResult2 = SubNibble(w3);

String w4 = XOR(XORResult3,NibbleResult2);

String w5 = XOR(w4,w3);
 String key2 = w4+w5;

String keys[] = {key1,key2};

return keys;

static String XOR(String a,String

b){ String c = "";

for(int i =

0;i<a.length();i++){ if(a.cha

rAt(i)==b.charAt(i))

c+="0";

else

c+="1";

return c;

}
 static String SubNibble(String

a){ String b =

RotNibble(a);

String SBox[][] =

{{"1001","0100","1010","1011"},{"1101","0001","1000","0101"},{"0110","0010","0000","0

011"},{"1100"

,"1110","1111","0111"}};

StringBuilder c = new StringBuilder(b);

StringBuilder leftBit = new StringBuilder(c.substring(0,4));

StringBuilder rightBit = new StringBuilder(c.substring(4));

StringBuilder result = new StringBuilder();

int rightBitRow = 0,rightBitCol = 0;

int leftBitRow = 0,leftBitCol = 0;

switch(leftBit.substring(0,2).toString()){

case "00":leftBitRow=0;

break;

case "01":leftBitRow=1;

break;
 case "10":leftBitRow=2;

break;

case "11":leftBitRow=3;

switch(leftBit.substring(2).toString()){

case "00":leftBitCol=0;

break;

case "01":leftBitCol=1;

break;

case "10":leftBitCol=2;

break;

case "11":leftBitCol=3;

switch(rightBit.substring(0,2).toString()){

case "00":rightBitRow=0;

break;

case "01":rightBitRow=1;
 break;

case "10":rightBitRow=2;

break;

case "11":rightBitRow=3;

switch(rightBit.substring(2).toString()){

case "00":rightBitCol=0;

break;

case "01":rightBitCol=1;

break;

case "10":rightBitCol=2;

break;

case "11":rightBitCol=3;

result.append(SBox[leftBitRow][leftBitCol]);

result.append(SBox[rightBitRow][rightBitCol]);

return result.toString();
 }

static String RotNibble(String a){

StringBuilder b = new StringBuilder(a.substring(4));

b.append(a.substring(0,4));

return b.toString();

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

AES cipher = new AES();

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

String pText = s.nextLine();

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

String key = s.nextLine();

String keys[] = cipher.KeyExpansion(key);

System.out.println(keys[0]+"\n"+keys[1]);

}
OUTPUT:

9. KEY GENERATION OF AES

CODE:

import java.util.*;

public class AES_KeyGenerator

static int z;

public static void main(String[] args)

{ Scanner sc=new

Scanner(System.in); int j;

System.out.println("Enter the key");

String s=sc.next();

char k[]=new char[s.length()];

 char ktemp[]=new char[s.length()];

for(j=0;j<s.length();j++)

k[j]=s.charAt(j);

for(z=0;z<10;z++)

ktemp=keyGen(k);

System.out.print("Round "+(z+1)+" : ");

System.out.print(ktemp);

System.out.println();

k=ktemp;

static char[] keyGen(char[] k)

char[] a=new char[k.length/4];

char[] a1=new char[k.length/4];

char[] a2=new char[k.length/4];

char[] a3=new char[k.length/4];

char[] a4=new char[k.length/4];

int i;

char [] w0=new char[k.length/4];

char [] w1=new char[k.length/4];

char [] w2=new char[k.length/4];

char [] w3 =new char[k.length/4];

char [] w4 =new char[k.length/4];

for(i=0;i<8;i++)

w0[i]=k[i];

for(i=0;i<8;i++)

w1[i]=k[8+i];

for(i=0;i<8;i++)
{

w2[i]=k[16+i];

for(i=0;i<8;i++)

w3[i]=k[24+i];

for(i=0;i<8;i++)

w4[i]=w3[i];

char c1=w3[0];

char c2=w3[1];

w3[0]=w3[2];

w3[1]=w3[3];

w3[2]=w3[4];

w3[3]=w3[5];

w3[4]=w3[6];

w3[5]=w3[7];
w3[6]=c1;

w3[7]=c2;

w3=subWord(w3);

w3=xor(w3,rConst());

a=xor(w0,w3);

a1=xor(a,w1);

a2=xor(a1,w2);

a3=xor(a2,w4);

for(i=0;i<8;i++)

a4[i]=a[i];

for(i=0;i<8;i++)

a4[i+8]=a1[i];

for(i=0;i<8;i++)
 {

a4[i+16]=a2[i];

for(i=0;i<8;i++)

a4[i+24]=a3[i];

return a4;

static char[] binToHexa(int k[])

int l=k.length;

char[] a=new char[l/4];

String s="";

for(int i=0;i<l/4;i++)

if(k[4*i]==0)
 s=s+"0";

else

s=s+"1";

if(k[4*i+1]==0)

s=s+"0";

else

s=s+"1";

if(k[4*i+2]==0)

s=s+"0";

else

s=s+"1";

if(k[4*i+3]==0)

s=s+"0";

else

s=s+"1";

if(s.equals("0000"))

a[i]='0';
else if(s.equals("0001"))

a[i]='1';

else if(s.equals("0010"))

a[i]='2';

else if(s.equals("0011"))

a[i]='3';

else if(s.equals("0100"))

a[i]='4';

else if(s.equals("0101"))

a[i]='5';

else if(s.equals("0110"))

a[i]='6';

else if(s.equals("0111"))

a[i]='7';

else if(s.equals("1000"))

a[i]='8';

else if(s.equals("1001"))
 a[i]='9';

else if(s.equals("1010"))

a[i]='A';

else if(s.equals("1011"))

a[i]='B';

else if(s.equals("1100"))

a[i]='C';

else if(s.equals("1101"))

a[i]='D';

else if(s.equals("1110"))

a[i]='E';

else

a[i]='F';

s="";

return(a);

}
static int[] hexaToBin(char k[])

int l=k.length;

int[] a=new int[4*l];

int i=0,j;

char c;

for(i=0;i<l;i++)

c=k[i];

if(c=='0')

a[4*i]=0;

a[4*i+1]=0;

a[4*i+2]=0;

a[4*i+3]=0;

else if(c=='1')
{

a[4*i]=0;

a[4*i+1]=0;

a[4*i+2]=0;

a[4*i+3]=1;

else if(c=='2')

a[4*i]=0;

a[4*i+1]=0;

a[4*i+2]=1;

a[4*i+3]=0;

else if(c=='3')

a[4*i]=0;

a[4*i+1]=0;
 a[4*i+2]=1;

a[4*i+3]=1;

else if(c=='4')

a[4*i]=0;

a[4*i+1]=1;

a[4*i+2]=0;

a[4*i+3]=0;

else if(c=='5')

a[4*i]=0;

a[4*i+1]=1;

a[4*i+2]=0;

a[4*i+3]=1;

}
else if(c=='6')

a[4*i]=0;

a[4*i+1]=1;

a[4*i+2]=1;

a[4*i+3]=0;

else if(c=='7')

a[4*i]=0;

a[4*i+1]=1;

a[4*i+2]=1;

a[4*i+3]=1;

else if(c=='8')

a[4*i]=1;
 a[4*i+1]=0;

a[4*i+2]=0;

a[4*i+3]=0;

else if(c=='9')

a[4*i]=1;

a[4*i+1]=0;

a[4*i+2]=0;

a[4*i+3]=1;

else if(c=='A')

a[4*i]=1;

a[4*i+1]=0;

a[4*i+2]=1;

a[4*i+3]=0;
}

else if(c=='B')

a[4*i]=1;

a[4*i+1]=0;

a[4*i+2]=1;

a[4*i+3]=1;

else if(c=='C')

a[4*i]=1;

a[4*i+1]=1;

a[4*i+2]=0;

a[4*i+3]=0;

else if(c=='D')

{
 a[4*i]=1;

a[4*i+1]=1;

a[4*i+2]=0;

a[4*i+3]=1;

else if(c=='E')

a[4*i]=1;

a[4*i+1]=1;

a[4*i+2]=1;

a[4*i+3]=0;

else

a[4*i]=1;

a[4*i+1]=1;

a[4*i+2]=1;
 a[4*i+3]=1;

return(a);

static char[] xor(char[] k1,char[] k2)

int[] a1=hexaToBin(k1);

int[] a2=hexaToBin(k2);

int[] a3=new int[a1.length];

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

if(a1[i]==0&&a2[i]==0)

a3[i]=0;

else if(a1[i]==1&&a2[i]==0)

a3[i]=1;

else if(a1[i]==0&&a2[i]==1)
 a3[i]=1;

else

a3[i]=0;

char a[]=binToHexa(a3);

return a;

static char[] rConst()

char[] a1= {'0','1','0','0','0','0','0','0'};

char[] a2= {'0','2','0','0','0','0','0','0'};

char[] a3= {'0','4','0','0','0','0','0','0'};

char[] a4= {'0','8','0','0','0','0','0','0'};

char[] a5= {'1','0','0','0','0','0','0','0'};

char[] a6= {'2','0','0','0','0','0','0','0'};

char[] a7= {'4','0','0','0','0','0','0','0'};

char[] a8= {'8','0','0','0','0','0','0','0'};

 char[] a9= {'1','B','0','0','0','0','0','0'};

char[] a10={'3','6','0','0','0','0','0','0'};

if(z==0)

return a1;

else if(z==1)

return a2;

else if(z==2)

return a3;

else if(z==3)

return a4;

else if(z==4)

return a5;

else if(z==5)

return a6;

else if(z==6)

return a7;

else if(z==7)
 return a8;

else if(z==8)

return a9;

else

return a10;

static char[] subWord(char[] c)

char[] a=new char[c.length];

String b[][]=

{{"63","7C","77","7B","F2","6B","6F","C5","30","01","67","2B","FE","D7","AB","76"},

{"CA","82","C9","7D","FA","59","47","F0","AD","D4","A2","AF","9C","A4","72","C0"},

{"B7","FD","93","26","36","3F","F7","CC","34","A5","E5","F1","71","D8","31","15"},

{"04","C7","23","C3","18","96","05","9A","07","12","80","E2","EB","27","B2","75"},
{"09","83","2C","1A","1B","6E","5A","A0","52","3B","D6","B3","29","E3","2F","84"},

{"53","D1","00","ED","20","FC","B1","5B","6A","CB","BE","39","4A","4C","58","CF"},

{"D0","EF","AA","FB","43","4D","33","85","45","F9","02","7F","50","3C","9F","AB"},

{"51","A3","40","8F","92","9D","38","F5","BC","B6","DA","21","10","FF","F3","D2"},

{"CD","0C","13","EC","5F","97","44","17","C4","A7","7E","3D","64","5D","19","73"},

{"60","81","4F","DC","22","2A","90","88","46","EE","B8","14","DE","5E","0B","DB"},

{"E0","32","3A","0A","49","06","24","5C","C2","D3","AC","62","91","95","E4","79"},

{"E7","CB","37","6D","8D","D5","4E","A9","6C","56","F4","EA","65","7A","AE","08"},

{"BA","78","25","2E","1C","A6","B4","C6","E8","DD","74","1F","4B","BD","8B","8A"},

{"70","3E","B5","66","48","03","F6","0E","61","35","57","B9","86","C1","1D","9E"},
{"E1","F8","98","11","69","D9","8E","94","9B","1E","87","E9","CE","55","28","DF"},

{"8C","A1","89","0D","BF","E6","42","68","41","99","2D","0F","B0","54","BB","16"}};

char[] b1= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

int i,j,k1=0,k2=0;

for(i=0;i<a.length;i=i+2)

for(j=0;j<b1.length;j++)

if(c[i]==b1[j])

k1=j;

for(j=0;j<b1.length;j++)

if(c[i+1]==b1[j])

k2=j;
 }

a[i]=b[k1][k2].charAt(0);

a[i+1]=b[k1][k2].charAt(1);

return a;

10. KEY GENERATION OF DES

CODE:

import java.util.*;

public class DES_KeyGenerator

static int[] key = {1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,1,0,0,0,0,1,0,0,1,0,0,0,1,

1,0,0,0,

0,0,1,0,

0,1,1,1,

0,0,1,1,
0,1,1,0,

1,1,0,0,

1,1,0,0,

1,1,0,1,

1,1,0,1};

static int[] reducedkey = new int[56];

static int[] left = new int[28]; static

int[] right = new int[28]; public

static void paritydropper()

int[] p

={57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,27,19,11,3,60,52,44,36,63,55,

47,39,31,23,15,7,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,28,20,12,4};

int a[] = new int[p.length];

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

a[i] = key[p[i]-1];
}

reducedkey = a;

for(int x : a)

System.out.print(x);

System.out.println();

public static void separator()

for(int i = 0 ; i < 28 ; i++)

left[i] = reducedkey[i];

right[i] = reducedkey[i+28];

public static int[] leftshifter(int[] a ,int n)

if(n == 1 || n == 2 || n == 9 || n == 16)
{

int b = a[0];

for(int i = 0 ; i <27 ; i++)

a[i] = a[i+1];

a[a.length-1] = b ;

return a;

else

int b0 = a[0];

int b1 = a[1];

for(int i = 0 ; i < 26 ; i++)

a[i] = a[i+2];

a[26] = b0;

a[27] = b1;

return a;

}
}

public static void combine()

for(int i = 0 ; i < 28 ; i++)

reducedkey[i] = left[i];

reducedkey[i+28] = right[i];

public static int[] compressor()

int[] p =

{14,17,11,24,1,5,3,28,15,6,21,10,23,19,12,4,26,8,16,7,27,20,13,2,41,52,31,37,47,55,30

,40,51,45,33,48,44,49,39,56,34,53,46,42,50,36,29,32};

int[] a = new int[p.length];

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

a[i] = reducedkey[p[i]-1];

return a;

public static void display(int[][] a , int i)

System.out.println();

for(int j = 0 ; j<48 ; j++)

System.out.print(a[i-1][j]);

System.out.println();

public static void main(String agrs[])

{
int[][] keyfinal = new int[16][] ;

paritydropper();

separator();

for(int i = 1 ; i <= 16 ; i++)

right = leftshifter(right,i);

left = leftshifter(left,i);

combine();

keyfinal[i-1] = compressor();

display(keyfinal,i);

11. DES

CODE:

import java.util.*;

public class DES{

String[] keyGeneration(String key0,int[] p10,int[]

p8){ StringBuilder Key1 = new

StringBuilder(key0);

//Apply P10

for(int i =

0;i<p10.length;i++){ Key1.setCharAt(i,key

0.charAt((p10[i])-1));

//Apply LS-1

StringBuilder rightBit = new StringBuilder(Key1.substring(0,5));

StringBuilder leftBit = new StringBuilder(Key1.substring(5));

StringBuilder lf1 = new StringBuilder(rightBit.substring(1));

lf1.append(rightBit.charAt(0));

StringBuilder lf2 = new StringBuilder(leftBit.substring(1));

lf2.append(leftBit.charAt(0));

lf1.append(lf2);

//Apply P8
 String key1 = "";

for(int i =

0;i<p8.length;i++){ key1+=Character.toString(lf

1.charAt((p8[i])-1));

//Apply LS-2

StringBuilder lf11 = new StringBuilder(lf1.substring(2,5));

lf11.append(lf1.charAt(0));lf11.append(lf1.charAt(1));

StringBuilder lf12 = new StringBuilder(lf1.substring(7));

lf12.append(lf1.charAt(5));lf12.append(lf1.charAt(6));

lf11.append(lf12);

//Apply P8

String key2 = "";

for(int i =

0;i<p8.length;i++){ key2+=Character.toString(lf1

1.charAt((p8[i])-1));

}
//Returning Keys

String keys[] = {key1,key2};

return keys;

String encryption1(String pText,int[] ip,String[] keys){

//Apply Ip

StringBuilder Ip = new StringBuilder(pText);

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

Ip.setCharAt(i,pText.charAt((ip[i])-1));

//Left-Right(L&R)

StringBuilder Fkey1Left = new StringBuilder(Ip.substring(0,4));

StringBuilder Fkey1Right = new StringBuilder(Ip.substring(4));

//Apply Ep

int ExpBox[] = {4,1,2,3,2,3,4,1};

StringBuilder Fkey1RightExpanded = new StringBuilder();

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

Fkey1RightExpanded.append(Fkey1Right.charAt((ExpBox[i])-1));

//XOR with K1

String XORresult = XOR(Fkey1RightExpanded.toString(),keys[0]);

StringBuilder xorResult = new StringBuilder(XORresult);

//S0 and S1

StringBuilder xorResultLeft = new

StringBuilder(xorResult.substring(0,4));

StringBuilder xorResultRight = new

StringBuilder(xorResult.substring(4));

//SBox and PBox

String SBoxResult =

SBox(xorResultLeft.toString(),xorResultRight.toString());

String PBoxResult = PBox(SBoxResult);

//XOR of L with output result

String XORresult1 = XOR(Fkey1Left.toString(),PBoxResult);

 //Concat with R

String finalResult0 = XORresult1+Fkey1Right.toString();

//Swap Halves

String finalResult1 = swap(finalResult0);

//Calling Round2 Encryption

String grandFinalResult = encryption2(finalResult1,ExpBox,keys[1]);

return grandFinalResult;

String encryption2(String FKey1,int Ep[],String k){

//Left-Right(L&R)

StringBuilder Fkey2Left = new StringBuilder(FKey1.substring(0,4));

StringBuilder Fkey2Right = new StringBuilder(FKey1.substring(4));

//Apply Ep

StringBuilder Fkey2RightExpanded = new StringBuilder();

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

Fkey2RightExpanded.append(Fkey2Right.charAt((Ep[i])-1));
 }

//XOR with K1

String XORresult = XOR(Fkey2RightExpanded.toString(),k);

StringBuilder xorResult = new StringBuilder(XORresult);

//S0 and S1

StringBuilder xorResultLeft = new

StringBuilder(xorResult.substring(0,4));

StringBuilder xorResultRight = new

StringBuilder(xorResult.substring(4));

//SBox and PBox

String SBoxResult =

SBox(xorResultLeft.toString(),xorResultRight.toString());

String PBoxResult = PBox(SBoxResult);

//XOR of L with output result

String XORresult1 = XOR(Fkey2Left.toString(),PBoxResult);

//Concat with R

String finalResult0 = XORresult1+Fkey2Right.toString();

String finalResult1 = "";

 //No Swapping this time

//Ip Inverse

int IpInverse[] = {4,1,3,5,7,2,8,6};

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

finalResult1+=Character.toString(finalResult0.charAt((IpInverse[i])-1));

return finalResult1;

static String SBox(String a,String

b){ String s0[][] =

{{"01","00","11","10"},{"11","10","01","00"},{"00","10","01","11"},{"11","01","11","10"}}

String s1[][] =

{{"00","01","10","11"},{"10","00","01","11"},{"11","00","01","00"},{"10","01","00","11"}}

String SZero = "";

String SOne = "";

 int SZeroRow = 0,SZeroCol = 0;

int SOneRow = 0,SOneCol = 0;

switch(Character.toString(a.charAt(0))+Character.toString(a.charAt(3))){

case "00":SZeroRow=0;

break;

case "01":SZeroRow=1;

break;

case "10":SZeroRow=2;

break;

case "11":SZeroRow=3;

switch(Character.toString(a.charAt(1))+Character.toString(a.charAt(2))){

case "00":SZeroCol=0;

break;

case "01":SZeroCol=1;
 break;

case "10":SZeroCol=2;

break;

case "11":SZeroCol=3;

switch(Character.toString(b.charAt(0))+Character.toString(b.charAt(3))){

case "00":SOneRow=0;

break;

case "01":SOneRow=1;

break;

case "10":SOneRow=2;

break;

case "11":SOneRow=3;

}
switch(Character.toString(b.charAt(1))+Character.toString(b.charAt(2))){

case "00":SOneCol=0;

break;

case "01":SOneCol=1;

break;

case "10":SOneCol=2;

break;

case "11":SOneCol=3;

SZero = s0[SZeroRow][SZeroCol];

SOne = s1[SOneRow][SOneCol];

//System.out.println(SZero+" "+SOne);

String result = SZero+SOne;

return result;

static String PBox(String a){

 int p4[] = {2,4,3,1};

String b = "";

for(int i =

0;i<p4.length;i++){ b+=Character.toString(

a.charAt((p4[i])-1));

return b;

static String swap(String a){

StringBuilder b = new StringBuilder(a);

StringBuilder c = new StringBuilder(b.substring(4));

c.append(b.substring(0,4));

return c.toString();

static String XOR(String a,String

b){ String c = "";

for(int i =

0;i<a.length();i++){ if(a.cha

rAt(i)==b.charAt(i))
 c+="0";

else

c+="1";

return c;

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

DES cipher= new DES();

int pTen[] = {3,5,2,7,4,10,1,9,8,6};

int pEight[] = {6,3,7,4,8,5,10,9};

int Ip[] = {2,6,3,1,4,8,5,7};

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

String pText = s.nextLine();

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

String key = s.nextLine();

String keys[] = cipher.keyGeneration(key,pTen,pEight);

 System.out.println("Key1 is:- "+keys[0]+"\n"+"Key2 is:- "+keys[1]);

String cipherText = cipher.encryption1(pText,Ip,keys);

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

OUTPUT: