Cryptography - Rail Fence Cipher

---

---

A basic type of transposition cipher is the rail fence method. It is a kind of cryptographic process where the letters in a message are rearranged to form a new, seemingly unrelated message. The name of the approach comes from the message we write. When a text is created using the rail fence approach, the outcome is a zigzag pattern where each letter is spelled out before going on to the next row.

The message has to be written in the first row of a table in order to be encrypted using the rail fence approach. In addition, the second letter of the message needs to be written in the second row. This procedure must be continued until all of the message's letters have been written. Finally, we read the database row-wise to create the encrypted message.

Let us get started now discuss how to decode a message. Finding the number of rows in the table depending on the encrypted message's length is the first step in decrypting it. In addition, we have to write the encrypted message's initial letter in the first row, its second letter in the second row, and so on. This process has to be followed until all of the message's letters have been written.

All things considered, the rail fence method of encryption is really straightforward. It does not offer very strong security. Even someone with a basic understanding of cryptography can easily break it. However, at times when a high level of security is not necessary, it can continue to be useful for simple communication.

How Rail Fence Cipher Work?

This section will give a detailed explanation of the encryption and decryption processes used by the rail fence cipher.

Encryption

In order to decrypt a message using the rail fence cipher, we should first choose the number of rails, write the message diagonally in a zigzag pattern using that number, and then combine the letters along each rail from left to right. We will walk through each step with an example below.

Let us start by considering "RAILFENCE" as a plaintext. Let us now assume that there are three rails or fences, which is also known as a key. The zigzag pattern's height will be determined by the key. The message can then be written diagonally, from left to right, in a zigzag pattern −

In order to create the ciphertext we will merge distinct rows, which in this case is "RFEALECIN."

Decryption

The number of rows and columns in the cipher text needs to be determined before we can start the decryption process. The length of the ciphertext is equal to the number of columns. After that, we need to determine how many rows-which function as the key-were encrypted.

Now that we know how many rows and columns there are, we can build the table and figure out where the letters should go because the rail fence cipher zigzags to encrypt the text diagonally from left to right −

The points where letters from the ciphertext are inserted to create the plaintext are indicated by the *(asterisk). Beginning from the top row, which is the first "rail," we fill in the letters going left to right. Up until all of the asterisk spots are filled with letters from the ciphertext, we then carry on with this pattern on the following rail and so on −

Let us finish the table above −

Finally, we are able to combine the characters from left to right and top to bottom to get the Plaintext, "RAILFENCE."

Implementation

Now we are going to implement the Rail Fence Cipher using Python, Java, C++ and Javascript.

Implement using Python

So first we will create a code suing Python and implement Rail Fence Cipher. We will create two different functions one for encryption and other one for decryption. So see the code below −

Example

# Function to encrypt a message
def encrypt_rail_fence(plaintext, rails):

   # Create the matrix for cipher
   rail_matrix = [['\n' for i in range(len(plaintext))]
   for j in range(rails)]
	
   # Find the direction
   down_direction = False
   row, col = 0, 0
	
   for i in range(len(plaintext)):
		
      # Check the direction of flow
      # Reverse the direction if just filled the top or bottom rail
      if (row == 0) or (row == rails - 1):
         down_direction = not down_direction
		
         # Fill the corresponding alphabet
         rail_matrix[row][col] = plaintext[i]
         col += 1
		
         # Find the next row using direction flag
         if down_direction:
            row += 1
         else:
            row -= 1
	
   # Construct the cipher using the rail matrix
   cipher_text = []
   for i in range(rails):
      for j in range(len(plaintext)):
         if rail_matrix[i][j] != '\n':
            cipher_text.append(rail_matrix[i][j])
      return("" . join(cipher_text))
	
# Function to decrypt the cipher-text
# Function to decrypt the cipher-text
def decrypt_rail_fence(cipher, rails):

   # Create the matrix to cipher
   # plaintext - rows, length(cipher) - columns
   # Fill the rail matrix to distinguish filled spaces from blank ones
   rail_matrix = [['\n' for i in range(len(cipher))]
   for j in range(rails)]
	
   # Find the direction
   down_direction = None
   row, col = 0, 0
	
   for i in range(len(cipher)):
		
      # Check the direction of flow
      if row == 0:
         down_direction = True
      if row == rails - 1:
         down_direction = False
		
      # Place the cipher text in the rail matrix
      rail_matrix[row][col] = '*'
      col += 1
		
      # Find the next row using direction flag
      if down_direction:
         row += 1
      else:
         row -= 1
			
   # Reconstruct the rail matrix with cipher text
   index = 0
   for i in range(rails):
      for j in range(len(cipher)):
         if rail_matrix[i][j] == '*' and index < len(cipher):
            rail_matrix[i][j] = cipher[index]
            index += 1
				
   # Read the rail matrix in zig-zag manner to construct the resultant text
   result = []
   row, col = 0, 0
   for i in range(len(cipher)):
		
      # Check the direction of flow
      if row == 0:
         down_direction = True
      if row == rails - 1:
         down_direction = False
			
      # Add characters from the rail matrix to the result
      if rail_matrix[row][col] != '*':
         result.append(rail_matrix[row][col])
         col += 1
			
      # Find the next row using direction flag
      if down_direction:
         row += 1
      else:
         row -= 1
	
      return ''.join(result)

# Driver code
if __name__ == "__main__":
   print("First Encrypted Text: ", encrypt_rail_fence("Hello Tutorialspoint", 2))
   print("Second Encrypted Text: ", encrypt_rail_fence("Simple Text", 3))
   print("Third Encrypted Text: ", encrypt_rail_fence("I am great Cipher", 5))
   # Decryption of the cipher-text
   print("First Decrypted Text: ", decrypt_rail_fence("HloTtrasonel uoilpit", 2))
   print("Second Decrypted Text: ", decrypt_rail_fence("SleipeTxm t", 3))
   print("Third Decrypted Text: ", decrypt_rail_fence("Iar etear hmgCp i", 5))

Following is the output of the above example −

Input/Output

First Encrypted Text:  HloTtrason
Second Encrypted Text:  S
Third Encrypted Text:  I
First Decrypted Text:  H
Second Decrypted Text:  S
Third Decrypted Text:  I

Implement using Java

Now we will implement the Rail fence Cipher using Java programming langugage. We will use the same approach what we have used in the Python. Here we will use Arrays library of Java for the purpose of Rail matrix. So the code is as follows −

Example

import java.util.Arrays;
public class CustomRailFence {

   //Encrypt a message
   public static String encryptMessage(String plaintext, int rails) {

      // Create the matrix
      char[][] railMatrix = new char[rails][plaintext.length()];

      // Filling the rail matrix
      for (int i = 0; i < rails; i++)
      Arrays.fill(railMatrix[i], '\n');

      boolean dirDown = false;
      int row = 0, col = 0;

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

         // Check the direction of flow
         if (row == 0 || row == rails - 1)
         dirDown = !dirDown;

         // Fill the corresponding alphabet
         railMatrix[row][col++] = plaintext.charAt(i);

         // Find the next row using direction flag
         if (dirDown)
            row++;
         else
            row--;
      }
      // Now we can create the cipher 
      StringBuilder result = new StringBuilder();
      for (int i = 0; i < rails; i++)
      for (int j = 0; j < plaintext.length(); j++)
      if (railMatrix[i][j] != '\n')
      result.append(railMatrix[i][j]);

      return result.toString();
   }

    //Decrypt the ciphertext
   public static String decryptMessage(String cipher, int rails) {
      // Create the matrix 
      char[][] railMatrix = new char[rails][cipher.length()];

      // Filling the rail matrix 
      for (int i = 0; i < rails; i++)
      Arrays.fill(railMatrix[i], '\n');

      // Find the direction
      boolean dirDown = true;

      int row = 0, col = 0;

      // Mark the places with '*'
      for (int i = 0; i < cipher.length(); i++) {
         // Check the direction of flow
         if (row == 0)
            dirDown = true;
         if (row == rails - 1)
            dirDown = false;

         // Place the marker
         railMatrix[row][col++] = '*';

         // Find the next row 
         if (dirDown)
            row++;
         else
            row--;
      }

      // Now we can produce the fill the rail matrix
      int index = 0;
      for (int i = 0; i < rails; i++)
      for (int j = 0; j < cipher.length(); j++)
      if (railMatrix[i][j] == '*' && index < cipher.length())
         railMatrix[i][j] = cipher.charAt(index++);

      StringBuilder result = new StringBuilder();

      row = 0;
      col = 0;
      for (int i = 0; i < cipher.length(); i++) {
         // Check the direction of flow
         if (row == 0)
         dirDown = true;
         if (row == rails - 1)
         dirDown = false;

         // Place the marker
         if (railMatrix[row][col] != '*')
         result.append(railMatrix[row][col++]);

         // Find the next row using direction flag
         if (dirDown)
            row++;
         else
            row--;
      }
      return result.toString();
   }

   // Driver function
   public static void main(String[] args) {
      // Encryption
      System.out.println("The Encrypted Messages: ");
      System.out.println(encryptMessage("hello world", 2));
      System.out.println(encryptMessage("Simple Text", 4));
      System.out.println(encryptMessage("Java is great", 5));

      // Now decryption of the same cipher-text
      System.out.println("\nThe Decrypted Messages: ");
      System.out.println(decryptMessage("hlowrdel ol", 2));
      System.out.println(decryptMessage("S ieTmletpx", 4));
      System.out.println(decryptMessage("Jga rvseaia t", 5));
   }
}

Following is the output of the above example −

Input/Output

The Encrypted Message: 
hlowrdel ol
S ieTmletpx
Jga rvseaia t

The Decrypted Messages: 
hello world
Simple Text
Java is great

Implement using C++

In this we will built C++ code to showcase the Rail Fence Cipher process. It will use necessary libraries like iostream and string. The program defines two main functions, encryptMessage and decryptMessage to encrypt and decrypt the message using Rail Fence. These functions use a matrix representation to create the Rail Fence Cipher algorithm, filling the matrix in a zigzag pattern as per the given number of rails. Here is the C++ program with encryption and decryption functions for Rail Fence Cipher −

Example

#include <iostream>
#include <string>
using namespace std;

// Function to encrypt a message using Rail Fence Cipher
string encryptMessage(string plaintext, int rails) {
   // Create a matrix to represent the rail fence
   char rail[rails][plaintext.length()];

   // Fill the rail matrix with newline characters
   for (int i = 0; i < rails; i++) {
      for (int j = 0; j < plaintext.length(); j++) {
         rail[i][j] = '\n';
      }
   }

   // Determine the direction of movement
   bool moveDown = false;
   int row = 0, col = 0;

   // Traverse the plaintext and fill the rail matrix
   for (int i = 0; i < plaintext.length(); i++) {
      if (row == 0 || row == rails - 1) {
         moveDown = !moveDown;
      }
      rail[row][col++] = plaintext[i];
      moveDown ? row++ : row--;
   }

   // Construct the cipher text from the rail matrix
   string ciphertext;
   for (int i = 0; i < rails; i++) {
      for (int j = 0; j < plaintext.length(); j++) {
         if (rail[i][j] != '\n') {
            ciphertext.push_back(rail[i][j]);
         }
      }
   }
   return ciphertext;
}

// Function to decrypt the cipher text using Rail Fence Cipher
string decryptMessage(string ciphertext, int rails) {
   char rail[rails][ciphertext.length()];

   // Fill the rail matrix with newline characters
   for (int i = 0; i < rails; i++) {
      for (int j = 0; j < ciphertext.length(); j++) {
         rail[i][j] = '\n';
      }
   }

   // Determine the direction of movement
   bool moveDown = true;
   int row = 0, col = 0;

   // Mark the places with '*'
   for (int i = 0; i < ciphertext.length(); i++) {
      if (row == 0) {
         moveDown = true;
      }
      if (row == rails - 1) {
         moveDown = false;
      }
      rail[row][col++] = '*';
      moveDown ? row++ : row--;
   }

   // Reconstruct the rail matrix with cipher text
   int index = 0;
   for (int i = 0; i < rails; i++) {
      for (int j = 0; j < ciphertext.length(); j++) {
         if (rail[i][j] == '*' && index < ciphertext.length()) {
            rail[i][j] = ciphertext[index++];
         }
      }
   }

   // Construct the plaintext from the rail matrix
   string plaintext;
   row = 0, col = 0;
   for (int i = 0; i < ciphertext.length(); i++) {
      if (row == 0) {
         moveDown = true;
      }
      if (row == rails - 1) {
         moveDown = false;
      }

      if (rail[row][col] != '*') {
         plaintext.push_back(rail[row][col++]);
      }
      moveDown ? row++ : row--;
   }
   return plaintext;
}

int main() {
   cout << "The Encrypted Messages: " << endl;
   cout << encryptMessage("hello Tutorialspoint", 2) << endl;
   cout << encryptMessage("Simple Text", 4) << endl;
   cout << encryptMessage("Cplusplus is great", 5) << endl;

   // Now decryption of the same cipher-text
   cout << "\nThe Decrypted Messages: " << endl;
   cout << decryptMessage("hloTtrasonel uoilpit", 2) << endl;
   cout << decryptMessage("S ieTmletpx", 4) << endl;
   cout << decryptMessage("Csapu etllirupsgs", 5) << endl;

   return 0;
}

Following is the output of the above example −

Input/Output

The Encrypted Messages: 
hloTtrasonel uoilpit
S ieTmletpx
Csapu etllirupsgs 

The Decrypted Messages: 
hello Tutorialspoint
Simple Text
Cptrgulus lpssiea

Complexity and Applications

• The number of rows required to create the message determines how complex the rail fence technique is. The encryption will become more complicated the more rows we use. Moreover, an attacker may find it more difficult to figure out the initial positions of the characters in the message if there are more rows.

• The rail fence technique is still not a very safe form of encryption, however, even with multiple rows. It is always open to certain forms of attacks, and attackers can quickly break them.

• In modern communication, the rail fence technique is not often used. It was an integral part of various basic, low-security protocols for communication. However, more secure solutions that are more appropriate for securing private data are now available.

• Using the rail fence method for educational games or activities for kids is one usage of it. It can be a quick and entertaining approach to go over the fundamentals of cryptography. It should not be used for any important security applications, though.

Advantages

We now understand the basic concept behind the rail fence method. Let's discuss the advantages −

• The rail fence approach has a number of benefits, including versatility, simplicity, and ease of usage.

• The rail fence technique is a useful option for basic communication when a greater level of security is not required because it is relatively easy to understand and apply. The rail fence technique can be carried out manually without the need for specialised tools or software.

• Finally, any number of rows can be used with the rail fence system. It lets the user select the degree of complexity that best suits their requirements.

Disadvantages

Now let us discuss the disadvantages of Rail Fence −

• This technique's primary disadvantages are its vulnerability to attacks, lack of security, and limited effectiveness.

• As anyone with even basic cryptography knowledge can easily break the rail fence technique, it is not a secure form of encryption. For longer messages, this method is also not very successful.

• Additionally, certain attack types, like known-plaintext attacks, can target the rail fence method. As a result, an attacker can simply initiate attacks to decrypt the data.

Limitation

With frequency analysis, the encryption of the rail fence cipher is easily broken. A number that is less than or equal to the length of the ciphertext acts as the encryption key. It is therefore very vulnerable to brute-force attacks.