Caesar Cipher Encryption & Decryption

Introduction

The Caesar Cipher is a simple encryption technique where each letter in the plaintext is shifted by a fixed number of places in the alphabet.

Understanding ord() and chr()

print(ord('A'))  # Output: 65 (ASCII value of 'A')
print(chr(66))   # Output: 'B' (Character for ASCII value 66)

Logic & Step-by-Step Implementation

1️⃣ Step 1: Understanding Character Shifting

Each letter in the alphabet has an ASCII value: - 'A' = 65, 'B' = 66, ..., 'Z' = 90 - We shift each letter by a given number of places (shift). - If the shift moves past 'Z', it wraps around using modulus (%).

Example with Shift = 3:

'A' → 'D'
'B' → 'E'
'Z' → 'C'  (Wraps around)

Formula:
New character = (current character index + shift) % 26 + ord('A')

2️⃣ Step 2: Precomputing the Shifted Alphabet

• We create two lists:
• encoder: Maps original letters to their shifted versions.
• decoder: Maps shifted letters back to the original.

Example (Shift = 3)

Original:  ABCDEFGHIJKLMNOPQRSTUVWXYZ
Encoded:   DEFGHIJKLMNOPQRSTUVWXYZABC
Decoded:   XYZABCDEFGHIJKLMNOPQRSTUVW

We store these mappings as strings for fast lookup.

Code Implementation

class CaesarCipher:
    """Implements a simple Caesar cipher for encryption and decryption."""

    def __init__(self, shift):
        encoder = [None] * 26
        decoder = [None] * 26

        for k in range(26):
            encoder[k] = chr((k + shift) % 26 + ord('A'))
            decoder[k] = chr((k - shift) % 26 + ord('A'))

        self._forward = ''.join(encoder)
        self._backward = ''.join(decoder)

    def encode(self, message):
        """Encrypts the message using the Caesar cipher."""
        return self._transform(message, self._forward)

    def decode(self, message):
        """Decrypts the message back to its original form."""
        return self._transform(message, self._backward)

    def _transform(self, msg, code):
        """Transforms a message using the given encoding/decoding map."""
        msg = list(msg)
        for k in range(len(msg)):
            if msg[k].isupper():
                j = ord(msg[k]) - ord('A')
                msg[k] = code[j]
        return ''.join(msg)

Example Usage

cipher = CaesarCipher(3)
encrypted = cipher.encode("HELLO")
decrypted = cipher.decode(encrypted)
print(encrypted)  # KHOOR
print(decrypted)  # HELLO

Time Complexity Analysis

Key Takeaways

✅ Simple & Efficient: Easy to implement and understand.
✅ Fast Execution: Linear time complexity ensures quick encryption/decryption.
✅ Limitations: Vulnerable to frequency analysis and brute-force attacks.

Conclusion

The Caesar Cipher is one of the simplest encryption techniques, ideal for learning the basics of cryptography. However, it is not secure for modern applications due to its predictable shifting pattern. 🚀