C Program For Encryption And Decryption Using Caesar Cipher

The Caesar cipher is one of the simplest and oldest encryption techniques, relying on a substitution method where each letter in the plaintext is replaced by a letter some fixed number of positions down the alphabet. In this article, you will learn how to implement encryption and decryption using the Caesar cipher in C programming.

Problem Statement

In situations requiring a basic level of text obfuscation or as an educational tool to understand fundamental cryptographic principles, a simple substitution cipher like the Caesar cipher can be employed. The core problem is to transform a given message (plaintext) into an unreadable form (ciphertext) and then reverse the process to recover the original message, all based on a consistent shift value, known as the key.

Example

Let's consider an example of encrypting and then decrypting a message using a shift key of 3.

Original Message: HELLO WORLD Encrypted Message: KHOOR ZRUOG Decrypted Message: HELLO WORLD

Background & Knowledge Prerequisites

To effectively understand and implement the Caesar cipher in C, readers should have a basic grasp of:

• C Programming Basics: Variables, data types (especially char), conditional statements (if, else if, else), loops (for, while), and functions.
• ASCII Values: Understanding that characters in C are represented by numerical ASCII values and how to perform arithmetic operations on them. For instance, 'A' is 65, 'B' is 66, and so on.
• Character Handling: Basic knowledge of character functions from like isalpha(), isupper(), islower(), though manual checks are also common.
• Modulo Operator (%): Its use in wrapping around a fixed range, which is crucial for handling alphabet shifts that go beyond 'Z' or 'z'.

Use Cases or Case Studies

While not suitable for modern secure communication, the Caesar cipher has several practical and educational applications:

• Educational Tool: It serves as an excellent starting point for teaching fundamental cryptography concepts, such as substitution, keys, and basic cryptanalysis.
• Historical Context: Demonstrates ancient communication methods, notably used by Julius Caesar for military correspondence.
• Puzzles and Games: Often featured in word puzzles, geocaching, or escape room challenges as a simple cipher to decode.
• Simple Obfuscation: For trivial cases where strong security is not required, but some level of data hiding is desired (e.g., storing hints in a game).
• Introduction to Modulo Arithmetic: Provides a tangible example for applying modulo operations in character manipulation.

Solution Approaches

The core idea behind the Caesar cipher is shifting characters. The primary approach involves iterating through the input string, identifying alphabetic characters, and then shifting them by the given key.

Approach: Character Shifting with Modulo Arithmetic

This approach focuses on systematically shifting each alphabetic character in a message, correctly handling both uppercase and lowercase letters, and wrapping around the alphabet using the modulo operator.

One-line summary: Implement Caesar cipher by iterating through a string, shifting alphabetic characters by a key, and using modulo arithmetic to ensure they wrap around the alphabet.

// Caesar Cipher Encryption and Decryption
#include <stdio.h>
#include <string.h>
#include <ctype.h> // For isalpha, isupper, islower

// Function to encrypt a character
char encryptChar(char ch, int key) {
    if (isalpha(ch)) {
        char base = isupper(ch) ? 'A' : 'a';
        return (char)(((ch - base + key) % 26) + base);
    }
    return ch; // Return non-alphabetic characters as is
}

// Function to decrypt a character
char decryptChar(char ch, int key) {
    if (isalpha(ch)) {
        char base = isupper(ch) ? 'A' : 'a';
        // Add 26 to handle negative results from (ch - base - key)
        return (char)(((ch - base - key + 26) % 26) + base);
    }
    return ch; // Return non-alphabetic characters as is
}

int main() {
    char message[100];
    int key;

    // Step 1: Get input message from the user
    printf("Enter a message: ");
    fgets(message, sizeof(message), stdin);
    // Remove trailing newline character if present
    message[strcspn(message, "\\n")] = 0;

    // Step 2: Get the encryption/decryption key
    printf("Enter the key (1-25): ");
    scanf("%d", &key);

    // Step 3: Normalize key to be within 0-25 range
    key = key % 26;
    if (key < 0) { // Handle negative keys to make them positive shifts
        key += 26;
    }

    // Step 4: Encrypt the message
    char encryptedMessage[100];
    strcpy(encryptedMessage, message); // Copy original message to encrypt
    for (int i = 0; encryptedMessage[i] != '\\0'; i++) {
        encryptedMessage[i] = encryptChar(encryptedMessage[i], key);
    }
    printf("Encrypted message: %s\\n", encryptedMessage);

    // Step 5: Decrypt the message
    char decryptedMessage[100];
    strcpy(decryptedMessage, encryptedMessage); // Copy encrypted message to decrypt
    for (int i = 0; decryptedMessage[i] != '\\0'; i++) {
        decryptedMessage[i] = decryptChar(decryptedMessage[i], key);
    }
    printf("Decrypted message: %s\\n", decryptedMessage);

    return 0;
}

Run

Sample Output:

Enter a message: HELLO WORLD
Enter the key (1-25): 3
Encrypted message: KHOOR ZRUOG
Decrypted message: HELLO WORLD

Stepwise Explanation:

1. Input Collection: The program first prompts the user to enter a message and a numerical key (shift value). The fgets function is used for safer string input, and strcspn removes the trailing newline.
2. Key Normalization: The input key is normalized using the modulo operator (% 26) to ensure it stays within the range of 0-25, which corresponds to shifts within the 26-letter alphabet. Negative keys are also adjusted.
3. encryptChar Function:

• It checks if the input character ch is an alphabet using isalpha().
• If it is, it determines the base character ('A' for uppercase, 'a' for lowercase).
• The character's position relative to its base (ch - base) is calculated.
• The key is added to this position.
• The result is then taken modulo 26 (% 26) to handle wrapping around the alphabet (e.g., 'Z' + 1 becomes 'A').
• Finally, the base is added back to convert the relative position back to an ASCII character.
• Non-alphabetic characters are returned unchanged.

1. decryptChar Function:

• Similar to encryptChar, it checks if the character is an alphabet and determines its base.
• For decryption, the key is subtracted.
• To correctly handle negative results that might occur from (ch - base - key) before applying modulo, 26 is added (+ 26). This ensures the result is always positive before the modulo operation, preventing incorrect wrapping.
• The modulo 26 is applied, and the base is added back.
• Non-alphabetic characters are returned unchanged.

1. Main Logic: The main function iteratively calls encryptChar for each character in the original message to create the encryptedMessage, and then iteratively calls decryptChar on the encryptedMessage to produce the decryptedMessage. The results are then printed.

Conclusion

The Caesar cipher provides a straightforward introduction to the principles of cryptography through a simple character-substitution mechanism. By shifting each letter in the alphabet by a fixed number of positions, messages can be easily encrypted and decrypted using basic arithmetic and character manipulation in C. While not secure for modern applications, it serves as an excellent foundation for understanding more complex cryptographic algorithms.

Summary

• Caesar Cipher Basics: A substitution cipher where each letter is shifted by a fixed key.
• Implementation Core: Iterating through a string, applying a shift to alphabetic characters, and using modulo arithmetic for wrapping.
• Encryption: (character - base + key) % 26 + base
• Decryption: (character - base - key + 26) % 26 + base (adding 26 to handle negative intermediate values).
• Key Normalization: Ensure the shift key is within the 0-25 range for consistent results.
• Character Handling: Differentiate between uppercase and lowercase letters, and preserve non-alphabetic characters.