Caesar Cipher Program in Java

The Caesar Cipher is a monoalphabetic substitution cipher. It is one of the simplest and most used encryption techniques. In this technique, each letter of the given text is replaced by a letter of some fixed number of positions down the alphabet.

For example, with a shift of 1, X would be replaced by Y, Y would become Z, and so on. Julius Caesar was the first one who used it for communicating with his officials. Based on his name, this technique was named as Caesar Cipher technique.

An integer value is required to cipher a given text. The integer value is known as shift, which indicates the number of positions each letter of the text has been moved down.

We can mathematically represent the encryption of a letter by a shift n in the following way:

Encryption phase with shift n = E_n (x) = (x+n)mod 26

Decryption phase with shift n = D_n (x) = (x-n)mod 26

Examples

Text : ABCDEFGHIJKLMNOPQRSTUVWXYZ

Shift : 23

Cipher : XYZABCDEFGHIJKLMNOPQRSTUVW

Text : ATTACKATONCE

Shift : 4

Cipher : EXXEGOEXSRGI

We use the following steps to implement the program for the Caesar Cipher technique:

Take an input string from the user to encrypt it using the Caesar Cipher technique.
Take an input integer from the user for shifting characters. The input integer should be between 0-25.
Traverse input string one character at a time.
Depending on the encryption and decryption, we transform each character as per the rule.
Returns the newly generated string.

Let's use the above-discussed steps and implement the code for the Caesar Cipher technique.

CaesarCipherExample.java

// import required classes and package, if any  
import java.util.Scanner; 
 
// create class CaesarCipherExample for encryption and decryption  
public class CaesarCipherExample 
{ 
    // ALPHABET string denotes alphabet from a-z 
    public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz"; 
    
    // create encryptData() method for encrypting user input string with given shift key 
    public static String encryptData(String inputStr, int shiftKey) 
    { 
        // convert inputStr into lower case 
        inputStr = inputStr.toLowerCase(); 
        
        // encryptStr to store encrypted data 
        String encryptStr = ""; 
        
        // use for loop for traversing each character of the input string 
        for (int i = 0; i < inputStr.length(); i++) 
        { 
            // get position of each character of inputStr in ALPHABET 
            int pos = ALPHABET.indexOf(inputStr.charAt(i)); 
            
            // get encrypted char for each char of inputStr 
            int encryptPos = (shiftKey + pos) % 26; 
            char encryptChar = ALPHABET.charAt(encryptPos); 
            
            // add encrypted char to encrypted string 
            encryptStr += encryptChar; 
        } 
        
        // return encrypted string 
        return encryptStr; 
    } 
    
    // create decryptData() method for decrypting user input string with given shift key 
    public static String decryptData(String inputStr, int shiftKey) 
    { 
        // convert inputStr into lower case 
        inputStr = inputStr.toLowerCase(); 
        
        // decryptStr to store decrypted data 
        String decryptStr = ""; 
        
        // use for loop for traversing each character of the input string 
        for (int i = 0; i < inputStr.length(); i++) 
        { 
            
            // get position of each character of inputStr in ALPHABET 
            int pos = ALPHABET.indexOf(inputStr.charAt(i)); 
            
            // get decrypted char for each char of inputStr 
            int decryptPos = (pos - shiftKey) % 26; 
            
            // if decryptPos is negative 
            if (decryptPos < 0){ 
                decryptPos = ALPHABET.length() + decryptPos; 
            } 
            char decryptChar = ALPHABET.charAt(decryptPos); 
            
            // add decrypted char to decrypted string 
            decryptStr += decryptChar; 
        } 
        // return decrypted string 
        return decryptStr; 
    } 
    
    // main() method start 
    public static void main(String[] args) 
    { 
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        // take input from the user 
        System.out.println("Enter a string for encryption using Caesar Cipher: "); 
        String inputStr = sc.nextLine(); 
        
        System.out.println("Enter the value by which each character in the plaintext message gets shifted: "); 
        int shiftKey = Integer.valueOf(sc.nextLine()); 
        
        System.out.println("Encrypted Data ===> "+encryptData(inputStr, shiftKey)); 
        System.out.println("Decrypted Data ===> "+decryptData(encryptData(inputStr, shiftKey), shiftKey)); 
        
        // close Scanner class object 
        sc.close(); 
    } 
} 

Output:

Explanation

The encryption and decryption method of the Caesar Cypher is implemented in this Java programme. The methods encryptData() and decryptData(), which carry out encryption and decryption, respectively, are defined in a class called CaesarCipherExample.

While the decryptData() function reverses this procedure, the encryptData() method moves each character by a defined key and changes the input string to lowercase. The primary method prints both the encrypted and decrypted strings after requesting the string to be encrypted and the shift key from the user. All things considered, the application offers a clear illustration of how the Caesar Cypher algorithm is implemented in Java.

Conclusion

To sum up, the Caesar Cypher is a basic encryption method that bears Julius Caesar's name. It entails moving each plaintext letter a certain number of positions either up or down the alphabet. The encryption and decryption procedure of the Caesar Cypher is clearly demonstrated by this Java programme, CaesarCipherExample.java. The application illustrates the fundamental ideas behind the cipher's operation through user input, text manipulation, and modular arithmetic.

The Caesar Cypher is a fundamental idea in cryptography, even though it is straightforward. It paves the way for more intricate encryption methods. Despite being susceptible to frequency analysis and brute force attacks, the cipher's historical relevance and educational value make it a useful teaching tool for students studying encryption and security.

Next TopicDifference between next() and nextLine()

← prev next →