Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Java Program to Encode a Message Using Playfair Cipher
Encrypting is the task of transforming information into an unreadable format or cipher text. It is usually done to protect the confidentiality of information. There are many ways and algorithms to encrypt data. One such example is the Playfair cipher algorithm. In this article, we are going to see how to write a Java program to encode a message using Playfair cipher.
Playfair cipher makes use of a 5X5 grid or matrix and a set of pre-defined rules. To encrypt, we require a key and the plain text to be encrypted.
Steps
Now let us see the steps to encrypt a message using Playfair cipher −
1. Generate the Key Table
This is the 5x5 grid of alphabets where no repetition is allowed. We start by putting each letter of the key in it followed by all the remaining alphabets. The letters i and j are considered to occupy the same cell in the grid as 5x5 is 25 and there are 26 alphabets in English, hence there would have to be some compromise.
2. Dividing the Plain text into Pairs
If the length of the plaintext is odd, we append the letter X to the end of it to make it even. We then split the entire plain text into pairs i.e. set of 2 letters each. E.g.: if the plain texts are of length 10, there will be 5 pairs of letters.
3. Iterate over the Pairs
For every pair of letters in the plaintext, we do the following −
If 2 continuous letters are same then insert an X between them.
Find the positions of the 2 letters in the grid created in step 1.
If the letters are in the same row, we replace each letter with the letter that is right. In case it is the last element in the row, we can go the first element of the row.
If the letters are in the same column, we replace each letter with the letter that is below it. In case it is the last element in the column, we can go the first element of the column.
If the letters are not in same column or same row, we replace each letter in the same row but in the column of the other letter.
4. The set of letters obtained after the previous step is the encrypted text.
Now let us see the above implementation in java.
Example
In the below example, we implement Playfair Cipher to Encode a Message.
public class PlayfairCipher {
private char[][] keyTable;
private static final int grid_dimension = 5;
private static final char APPEND = 'X';
public PlayfairCipher(String key) {
keyTable = generateKeyTable(key);
}
private char[][] generateKeyTable(String key) {
// Initialize the key table with all ' ' characters
char[][] table = new char[grid_dimension][grid_dimension];
for (int i = 0; i < grid_dimension; i++) {
for (int j = 0; j < grid_dimension; j++) {
table[i][j] = ' ';
}
}
// Fill the key table with the letters of the key
int row = 0;
int col = 0;
boolean[] used = new boolean[26];
for (int i = 0; i < key.length(); i++) {
char ch = Character.toUpperCase(key.charAt(i));
if (ch == 'J') {
ch = 'I';
}
if (!used[ch - 'A']) {
table[row][col] = ch;
used[ch - 'A'] = true;
col++;
if (col == grid_dimension) {
row++;
col = 0;
}
}
}
// Fill the remaining cells of the key table with the remaining letters of the alphabet
for (int i = 0; i < 26; i++) {
char ch = (char) ('A' + i);
if (ch == 'J') {
continue;
}
if (!used[i]) {
table[row][col] = ch;
col++;
if (col == grid_dimension) {
row++;
col = 0;
}
}
}
return table;
}
public String encrypt(String plaintext) {
plaintext = preprocess(plaintext);
StringBuilder ciphertext = new StringBuilder();
for (int i = 0; i < plaintext.length(); i += 2) {
char ch1 = plaintext.charAt(i);
char ch2 = plaintext.charAt(i + 1);
int[] position1 = findPosition(ch1);
int[] position2 = findPosition(ch2);
if (position1[0] == position2[0]) {
// When letters exist in same row
int newCol1 = (position1[1] + 1) % grid_dimension;
int newCol2 = (position2[1] + 1) % grid_dimension;
ciphertext.append(keyTable[position1[0]][newCol1]);
ciphertext.append(keyTable[position2[0]][newCol2]);
} else if (position1[1] == position2[1]) {
// When letters exist in same column
int newRow1 = (position1[0] + 1) % grid_dimension;
int newRow2 = (position2[0] + 1) % grid_dimension;
ciphertext.append(keyTable[newRow1][position1[1]]);
ciphertext.append(keyTable[newRow2][position2[1]]);
} else {
// When letters are not in the same column or in the same row
ciphertext.append(keyTable[position1[0]][position2[1]]);
ciphertext.append(keyTable[position2[0]][position1[1]]);
}
}
return ciphertext.toString();
}
public String decrypt(String ciphertext) {
StringBuilder plaintext = new StringBuilder();
for (int i = 0; i < ciphertext.length(); i += 2) {
char ch1 = ciphertext.charAt(i);
char ch2 = ciphertext.charAt(i + 1);
int[] position1 = findPosition(ch1);
int[] position2 = findPosition(ch2);
if (position1[0] == position2[0]) {
int newCol1 = (position1[1] + grid_dimension - 1) % grid_dimension;
int newCol2 = (position2[1] + grid_dimension - 1) % grid_dimension;
plaintext.append(keyTable[position1[0]][newCol1]);
plaintext.append(keyTable[position2[0]][newCol2]);
} else if (position1[1] == position2[1]) {
int newRow1 = (position1[0] + grid_dimension - 1) % grid_dimension;
int newRow2 = (position2[0] + grid_dimension - 1) % grid_dimension;
plaintext.append(keyTable[newRow1][position1[1]]);
plaintext.append(keyTable[newRow2][position2[1]]);
} else {
plaintext.append(keyTable[position1[0]][position2[1]]);
plaintext.append(keyTable[position2[0]][position1[1]]);
}
}
return postprocess(plaintext.toString());
}
private String preprocess(String text) {
// Replace J with I and add padding if needed
StringBuilder sb = new StringBuilder(text.toUpperCase().replaceAll("[^A-Z]", ""));
for (int i = 1; i < sb.length(); i += 2) {
if (sb.charAt(i) == sb.charAt(i - 1)) {
sb.insert(i, APPEND);
}
}
if (sb.length() % 2 != 0) {
sb.append(APPEND);
}
return sb.toString();
}
private String postprocess(String text) {
// Remove padding and replace X with the original character
StringBuilder sb = new StringBuilder(text);
for (int i = 1; i < sb.length(); i += 2) {
if (sb.charAt(i) == APPEND) {
sb.deleteCharAt(i);
}
}
return sb.toString().replace(APPEND, ' ');
}
private int[] findPosition(char ch) {
int[] pos = new int[2];
for (int i = 0; i < grid_dimension; i++) {
for (int j = 0; j < grid_dimension; j++) {
if (keyTable[i][j] == ch) {
pos[0] = i;
pos[1] = j;
return pos;
}
}
}
return null;
}
public static void main(String[] args) {
String plaintext = "MOSQUE";
String key = "MONARCHY";
PlayfairCipher cipher = new PlayfairCipher(key);
String ciphertext = cipher.encrypt(plaintext);
System.out.println("Plaintext: " + plaintext);
System.out.println("Ciphertext: " + ciphertext);
System.out.println("Decrypted text: " + cipher.decrypt(ciphertext));
}
}
Output
The above program will produce the following output -
Plaintext: MOSQUE Ciphertext: ONTSML Decrypted text: MOSQUE
Conclusion
Playfair cipher is a substitution cipher which makes use of a 5x5 grid of letters. It follows a set of if else based rules which leaves no room for ambiguity. It provides a stronger level of security compared to simple substitution cipher. It is easy to understand and implement. Although it has its own set of weaknesses like susceptibility to known plaintext attacks and its key management issues and inability to encrypt characters which are not letters, it is an interesting and historical example of symmetric encryption algorithm. It is no longer used to establish real life secure communication but provides a great understanding of basic concepts and techniques used in modern day encryption algorithms.
2K+ Views
