Playfair Cipher Program in Java

Playfair cipher is proposed by Charles Whetstone in 1889. But it was named for one of his friends Lord Lyon Playfair because he popularized its uses. It is the most popular symmetric encryption technique that falls under the substitution cipher. It is an encoding procedure that enciphers more than one letter at a time. In this section, we will discuss Playfair cipher along with its implementation in a Java program.

Playfair Cipher

Playfair cipher is an encryption algorithm to encrypt or encode a message. It is the same as a traditional cipher. The only difference is that it encrypts a digraph (a pair of two letters) instead of a single letter.

It initially creates a key-table of 5*5 matrix. The matrix contains alphabets that act as the key for encryption of the plaintext. Note that any alphabet should not be repeated. Another point to note that there are 26 alphabets and we have only 25 blocks to put a letter inside it. Therefore, one letter is excess so, a letter will be omitted (usually J) from the matrix. Nevertheless, the plaintext contains J, then J is replaced by I. It means treat I and J as the same letter, accordingly.

Since Playfair cipher encrypts the message digraph by digraph. Therefore, the Playfair cipher is an example of a digraph substitution cipher.

Before moving ahead, let's understand the terminology used in this Playfair cipher.

Terminology

Plaintext: It is the original message that is to be encrypted. It is also known as a message.
Ciphertext: It is an encrypted message.
Cipher: It is an algorithm for transforming plaintext to ciphertext.
Key: It is the key to encrypt or decrypt the plaintext. It is known only to the sender and receiver. It is filled character by character in the matrix that is called key-table or key-matrix.
Encipher: The process of converting plaintext into ciphertext is called encipher.
Decipher: The process of removing ciphertext from plaintext is called decipher.
Cryptanalysis: It is the study of the methods and principles of deciphering ciphertext without knowing the key.

Advantages of Playfair Cipher

Diverse ciphertext if we scrutinize the Algorithm, we can notice at every Stage we are getting diverse ciphertext, thus more trouble to cryptanalyst.
Brute force attack does not affect it.
Cryptanalyze (the process of decoding cipher without knowing key) is not possible.
Overcomes the limitation of simple Playfair square cipher.
Easy to perform the substitution.

Limitations of Playfair Cipher

The limitations of the Playfair cipher are as follows:

Only 25 alphabets are supported.
It does not support numeric characters.
Only either upper cases or lower cases are supported.
The use of special characters (such as blank space, newline, punctuations, etc.) is prohibited.
It does not support other languages, except English.
Encryption of media files is also not supported.

Playfair Cipher Encryption Rules

1. First, split the plaintext into digraphs (pair of two letters). If the plaintext has the odd number of letters, append the letter Z at the end of the plaintext. It makes the plaintext of even For example, the plaintext MANGO has five letters. So, it is not possible to make a digraph. Since, we will append a letter Z at the end of the plaintext, i.e. MANGOZ.

2. After that, break the plaintext into digraphs (pair of two letters). If any letter appears twice (side by side), put X at the place of the second occurrence. Suppose, the plaintext is COMMUNICATE then its digraph becomes CO MX MU NI CA TE. Similarly, the digraph for the plaintext JAZZ will be JA ZX ZX, and for plaintext GREET, the digraph will be GR EX ET.

3. To determine the cipher (encryption) text, first, build a 5*5 key-matrix or key-table and filled it with the letters of alphabets, as directed below:

Fill the first row (left to right) with the letters of the given keyword (ATHENS). If the keyword has duplicate letters (if any) avoid them. It means a letter will be considered only once. After that, fill the remaining letters in alphabetical order. Let's create a 5*5 key-matrix for the keyword ATHENS.

Note that in the above matrix any letter is not repeated. The letters in the first row (in green color) represent the keyword and the remaining letters sets in alphabetical order.

4. There may be the following three conditions:

i) If a pair of letters (digraph) appears in the same row

In this case, replace each letter of the digraph with the letters immediately to their right. If there is no letter to the right, consider the first letter of the same row as the right letter. Suppose, Z is a letter whose right letter is required, in such case, T will be right to Z.

ii) If a pair of letters (digraph) appears in the same column

In this case, replace each letter of the digraph with the letters immediately below them. If there is no letter below, wrap around to the top of the same column. Suppose, W is a letter whose below letter is required, in such case, V will be below W.

iii) If a pair of letters (digraph) appears in a different row and different column

In this case, select a 3*3 matrix from a 5*5 matrix such that pair of letters appear in the 3*3 matrix. Since they occupy two opposite corners of a square within the matrix. The other corner will be a cipher for the given digraph.

In other words, we can also say that intersection of H and Y will be the cipher for the first letter and

Suppose, a digraph is HY and we have to find a cipher for it. We observe that both H and Y are placed in different rows and different columns. In such cases, we have to select a 3*3 matrix in such a way that both H and Y appear in the 3*3 matrix (highlighted with yellow color). Now, we will consider only the selected matrix to find the cipher.

Now to find the cipher for HY, we will consider the diagonal opposite to HY, i.e. LU. Therefore, the cipher for H will be L, and the cipher for Y will be U.

Note: The order of the letters within the digraph is not important.

Playfair Cipher Decryption

The decryption procedure is the same as encryption but the steps are applied in reverse order. For decryption cipher is symmetric (move left along rows and up along columns). The receiver of the plain text has the same key and can create the same key-table that is used to decrypt the message.

Let's see an example of Playfair cipher.

Example of Playfair Cipher

Suppose, the plaintext is COMMUNICATION and the key that we will use to encipher the plaintext is COMPUTER. The key can be any word or phrase. Let's encipher the message COMMUNICATION.

1. First, split the plaintext into digraph (by rule 2) i.e. CO MX MU NI CA TE.

2. Construct a 5*5 key-matrix (by rule 3). In our case, the key is COMPUTER.

3. Now, we will traverse in key-matrix pair by pair and find the corresponding encipher for the pair.

The first digraph is CO. The pair appears in the same row. By using Rule 4(i) CO gets encipher into OM.
The second digraph is MX. The pair appears in the same column. By using Rule 4(ii) MX gets encipher into RM.
The third digraph is MU. The pair appears in the same row. By using Rule 4(i) MU gets encipher into PC.
The fourth digraph is NI. The pair appears in different rows and different columns. By using Rule 4(iii) NI gets encipher into SG.
The fifth digraph is CA. The pair appears in different rows and different columns. By using Rule 4(iii) CA gets encipher into PT.
The sixth digraph is TE. The pair appears in the same row. By using Rule 4(i) TE gets encipher into ER.

Therefore, the plaintext COMMUNICATE gets encipher (encrypted) into OMRMPCSGPTER.

Let's implement the above logic in a Java program.

Playfair Java Program

PlayfairCipher.java

import java.awt.Point;
import java.util.Scanner;
public class PlayfairCipher
{
//length of digraph array
private int length = 0;
//creates a matrix for Playfair cipher 
private String [][] table;
//main() method to test Playfair method
public static void main(String args[])
{
PlayfairCipher pf = new PlayfairCipher();
}
//main run of the program, Playfair method
//constructor of the class
private PlayfairCipher()
{
//prompts user for the keyword to use for encoding & creates tables
System.out.print("Enter the key for playfair cipher: ");
Scanner sc = new Scanner(System.in);
String key = parseString(sc);
while(key.equals(""))
key = parseString(sc);
table = this.cipherTable(key);
//prompts user for message to be encoded
System.out.print("Enter the plaintext to be encipher: ");
//System.out.println("using the previously given keyword");
String input = parseString(sc);
while(input.equals(""))
input = parseString(sc);
//encodes and then decodes the encoded message
String output = cipher(input);
String decodedOutput = decode(output);
//output the results to user
this.keyTable(table);
this.printResults(output,decodedOutput);
}
//parses an input string to remove numbers, punctuation,
//replaces any J's with I's and makes string all caps
private String parseString(Scanner sc)
{
String parse = sc.nextLine();
//converts all the letters in upper case
parse = parse.toUpperCase();
//the string to be substituted by space for each match (A to Z)
parse = parse.replaceAll("[^A-Z]", "");
//replace the letter J by I
parse = parse.replace("J", "I");
return parse;
}
//creates the cipher table based on some input string (already parsed)
private String[][] cipherTable(String key)
{
//creates a matrix of 5*5	
String[][] playfairTable = new String[5][5];
String keyString = key + "ABCDEFGHIKLMNOPQRSTUVWXYZ";
//fill string array with empty string
for(int i = 0; i < 5; i++)
for(int j = 0; j < 5; j++)
playfairTable[i][j] = "";
for(int k = 0; k < keyString.length(); 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("" + keyString.charAt(k)))
{
repeat = true;
}
else if(playfairTable[i][j].equals("") && !repeat && !used)
{
playfairTable[i][j] = "" + keyString.charAt(k);
used = true;
}
}
}
}
return playfairTable;
}
//cipher: takes input (all upper-case), encodes it, and returns the output
private String cipher(String in)
{
length = (int) in.length() / 2 + in.length() % 2;
//insert x between double-letter digraphs & redefines "length"

for(int i = 0; i < (length - 1); i++)
{
if(in.charAt(2 * i) == in.charAt(2 * i + 1))
{
in = new StringBuffer(in).insert(2 * i + 1, 'X').toString();
length = (int) in.length() / 2 + in.length() % 2;
}
}
//------------makes plaintext of even length--------------
//creates an array of digraphs
String[] digraph = new String[length];
//loop iterates over the plaintext
for(int j = 0; j < length ; j++)
{
//checks the plaintext is of even length or not	
if(j == (length - 1) && in.length() / 2 == (length - 1))
//if not addends X at the end of the plaintext 	
in = in + "X";
digraph[j] = in.charAt(2 * j) +""+ in.charAt(2 * j + 1);
}
//encodes the digraphs and returns the output
String out = "";
String[] encDigraphs = new String[length];
encDigraphs = encodeDigraph(digraph);
for(int k = 0; k < length; k++)
out = out + encDigraphs[k];
return out;
}
//---------------encryption logic-----------------
//encodes the digraph input with the cipher's specifications
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();
//executes if the letters of digraph appear in the same row
//in such case shift columns to right
if(r1 == r2)
{
c1 = (c1 + 1) % 5;
c2 = (c2 + 1) % 5;
}
//executes if the letters of digraph appear in the same column
//in such case shift rows down
else if(c1 == c2)
{
r1 = (r1 + 1) % 5;
r2 = (r2 + 1) % 5;
}
//executes if the letters of digraph appear in the different row and different column
//in such case swap the first column with the second column
else
{
int temp = c1;
c1 = c2;
c2 = temp;
}
//performs the table look-up and puts those values into the encoded array
encipher[i] = table[r1][c1] + "" + table[r2][c2];
}
return encipher;
}
//-----------------------decryption logic---------------------
// decodes the output given from the cipher and decode methods (opp. of encoding process)
private String decode(String out)
{
String decoded = "";
for(int i = 0; i < out.length() / 2; i++)
{
char a = out.charAt(2*i);
char b = out.charAt(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
{
//swapping logic	
int temp = c1;
c1 = c2;
c2 = temp;
}
decoded = decoded + table[r1][c1] + table[r2][c2];
}
//returns the decoded message
return decoded;
}
// returns a point containing the row and column of the letter
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;
}
//function prints the key-table in matrix form for playfair cipher
private void keyTable(String[][] printTable)
{
System.out.println("Playfair Cipher Key Matrix: ");
System.out.println();
//loop iterates for rows
for(int i = 0; i < 5; i++)
{
//loop iterates for column	
for(int j = 0; j < 5; j++)
{
//prints the key-table in matrix form	
System.out.print(printTable[i][j]+" ");
}
System.out.println();
}
System.out.println();
}  
//method that prints all the results
private void printResults(String encipher, String dec)
{
System.out.print("Encrypted Message: ");
//prints the encrypted message
System.out.println(encipher);
System.out.println();
System.out.print("Decrypted Message: ");
//prints the decryted message
System.out.println(dec);
}
}

Output 1:

Output 2:

Output 3:

In comparison to monoalphabetic cipher, the Playfair cipher (polyalphabetic cipher) is more secure. Because in monoalphabetic cipher the attacker has to search only in 26 letters. While in polyalphabetic cipher attacker has to search for 26² (676) digraphs. An attacker can still break the cipher in monoalphabetic cipher. Although frequency analysis is much more difficult and it uses modern computational techniques. Therefore, performing double substitution and transposition on Playfair cipher substantially increases its security.

Next TopicJava.lang.outofmemoryerror: java heap space

← prev next →