---

The Complete Guide to the Rotational Cipher in Cairo

The Rotational Cipher, a classic encryption technique also known as the Caesar Cipher, shifts letters by a fixed integer key. This comprehensive guide details its implementation in Cairo, covering character wrapping, modular arithmetic, and leveraging Cairo's unique features for a robust, educational, and provable solution from scratch.

You’ve probably heard stories of ancient generals sending secret messages, encoded so that only their trusted lieutenants could decipher them. This isn't just the stuff of Hollywood movies; it's the very origin of cryptography. One of the earliest and most famous methods was the Caesar Cipher, used by Julius Caesar himself. It's simple, elegant, and a perfect starting point for understanding the fundamentals of encryption.

But what happens when you try to implement this ancient technique in a hyper-modern, provable programming language like Cairo? You might find yourself wrestling with unfamiliar data types like felt252, figuring out string manipulation, or getting tangled in the nuances of modular arithmetic. It can feel like trying to fit a square peg in a round hole. This guide is here to bridge that gap. We will demystify the process, turning a potentially frustrating exercise into a powerful learning experience that solidifies your understanding of both cryptography basics and Cairo's core mechanics.

---

What Exactly is a Rotational Cipher?

At its heart, the Rotational Cipher is a type of substitution cipher where each letter in the plaintext is "shifted" a certain number of places down the alphabet. This "certain number" is the key. If you have a key of 3, 'A' becomes 'D', 'B' becomes 'E', and so on. When you reach the end of the alphabet, you simply wrap around to the beginning. With a key of 3, 'X' becomes 'A', 'Y' becomes 'B', and 'Z' becomes 'C'.

This is why it's called a "rotational" cipher—you can imagine the alphabet arranged in a circle, and you're just rotating it by the key's value.

Key Terminology

• Plaintext: The original, unencrypted message (e.g., "Hello World").
• Ciphertext: The resulting encrypted message (e.g., "Khoor Zruog" with a key of 3).
• Key: The integer value determining the shift (e.g., 3). The key is typically between 0 and 26 for the English alphabet.
• ROT+<key>: A common notation for this cipher. For example, a rotation of 13 is famously known as ROT13.

The magic of the cipher lies in modular arithmetic. The formula to encrypt a single character is:

ciphertext_char = (plaintext_char + key) % 26

This formula ensures that the result always "wraps around" the 26 letters of the alphabet. A key of 0 or 26 results in no change, as the rotation completes a full circle.

---

Why Implement This Cipher in Cairo?

Implementing a simple algorithm like the Rotational Cipher in a language like Python or JavaScript is straightforward. Doing it in Cairo, however, offers a unique set of challenges and learning opportunities that are invaluable for any Starknet developer. Cairo is not just another general-purpose language; it's designed for provable computation, which influences its design and standard library.

Tackling this problem in Cairo forces you to understand:

• String Manipulation: Cairo handles strings differently from many other languages. You'll work with types like ByteArray, gaining a deeper appreciation for how text data is represented and manipulated at a lower level.
• Type Safety and Conversions: Cairo's strong type system requires you to be explicit. You'll be converting characters (bytes) to integers (like u8 or u32) to perform arithmetic and then back again, reinforcing good practices.
• Core Logic and Control Flow: You'll master fundamental control flow structures like loops and conditional statements (if/else or match) within the Cairo syntax.
• Modular Thinking: The entire algorithm is a perfect, self-contained module. This aligns perfectly with the "component-based" thinking encouraged in the Cairo ecosystem, as detailed in the Cairo 2 learning roadmap from kodikra.com.

Essentially, this exercise serves as a perfect "kata"—a small, focused practice problem—to sharpen your fundamental Cairo skills before you move on to more complex smart contracts and decentralized applications.

High-Level Logic Flow

Before diving into the code, let's visualize the overall process. We take a message and a key, process each character one by one, and build a new, encrypted message.

    ● Start
    │
    ▼
  ┌────────────────────────┐
  │ Get Plaintext & Key    │
  └───────────┬────────────┘
              │
              ▼
  ┌────────────────────────┐
  │ Initialize Ciphertext  │
  └───────────┬────────────┘
              │
    ▶ Loop For Each Character in Plaintext
    │         │
    │         ▼
    │     ┌───────────────────┐
    │     │ Process Character │
    │     └─────────┬─────────┘
    │               │
    │               ▼
    │     ┌───────────────────┐
    │     │ Append to         │
    │     │ Ciphertext        │
    │     └───────────────────┘
    │
    ◀ End Loop
              │
              ▼
  ┌────────────────────────┐
  │ Return Ciphertext      │
  └───────────┬────────────┘
              │
              ▼
    ● End

---

How to Implement the Rotational Cipher in Cairo

Now, let's get our hands dirty and build the solution. We'll be using a standard Cairo project setup with Scarb, the Cairo package manager.

Project Setup

If you haven't already, create a new project using the Scarb command line tool.

$ scarb new rotational_cipher
$ cd rotational_cipher

This creates a `src/lib.cairo` file where we will write our logic. Open this file and replace its contents with our implementation.

The Complete Cairo Solution

Here is the full, well-commented code for implementing the rotational cipher. We'll create a primary function called rotate that handles the logic.

// Import the ByteArray type for string manipulation.
use core::byte_array::ByteArray;
use core::option::OptionTrait;

/// Rotates characters in a string by a given key, implementing the Caesar cipher.
///
/// # Arguments
///
/// * `text` - The input text as a ByteArray.
/// * `key` - The integer shift value (0-26).
///
/// # Returns
///
/// A new ByteArray containing the rotated (encrypted) text.
fn rotate(text: @ByteArray, key: u8) -> ByteArray {
    // Initialize an empty ByteArray to store the result.
    let mut result = ByteArrayTrait::new();

    // Create a snapshot of the input text to iterate over it.
    // A Span allows us to get a view of the data without taking ownership.
    let text_span = text.span();

    // Iterate over each byte (character) in the input text span.
    for byte in text_span {
        // We convert the key to u32 for arithmetic operations to avoid overflow issues
        // with intermediate calculations, even though the key itself is small.
        let key_u32: u32 = key.into();

        // Check if the character is a lowercase letter ('a' to 'z').
        // ASCII values for 'a' is 97, 'z' is 122.
        if *byte >= 'a' && *byte <= 'z' {
            // Convert byte to u32 for calculation.
            let char_code: u32 = (*byte).into();
            let base: u32 = 'a'.into();

            // 1. Normalize the character to a 0-25 range.
            let normalized_char = char_code - base;
            // 2. Add the key.
            let shifted_char = normalized_char + key_u32;
            // 3. Apply the modulo operator to wrap around the alphabet.
            let wrapped_char = shifted_char % 26;
            // 4. Convert back to the ASCII code by adding the base.
            let new_char_code = base + wrapped_char;
            
            // Append the new character to the result ByteArray.
            // We must convert it back to a u8. `try_into()` returns an Option,
            // so we unwrap it, assuming it will always succeed here.
            result.append_byte(new_char_code.try_into().unwrap());
        } 
        // Check if the character is an uppercase letter ('A' to 'Z').
        // ASCII values for 'A' is 65, 'Z' is 90.
        else if *byte >= 'A' && *byte <= 'Z' {
            // Convert byte to u32 for calculation.
            let char_code: u32 = (*byte).into();
            let base: u32 = 'A'.into();

            // Same logic as for lowercase letters, but with the uppercase base.
            let normalized_char = char_code - base;
            let shifted_char = normalized_char + key_u32;
            let wrapped_char = shifted_char % 26;
            let new_char_code = base + wrapped_char;

            // Append the new character to the result ByteArray.
            result.append_byte(new_char_code.try_into().unwrap());
        } 
        // If the character is not an alphabet letter (e.g., space, punctuation, number).
        else {
            // Append the original character to the result without any changes.
            result.append_byte(*byte);
        }
    }

    // Return the final encrypted ByteArray.
    result
}

Detailed Code Walkthrough

Let's break down the code step-by-step to understand what's happening.

1. Function Signature and Setup:

   fn rotate(text: @ByteArray, key: u8) -> ByteArray {
       let mut result = ByteArrayTrait::new();
       let text_span = text.span();
       ...
   }

   We define a function rotate that accepts a snapshot of a ByteArray (@ByteArray) and a key of type u8 (an 8-bit unsigned integer, perfect for 0-255, covering our 0-26 range). It returns a new ByteArray. Inside, we initialize a mutable result to build our output string and create a span to iterate over the input text without consuming it.

2. Iterating and Handling Characters:

   for byte in text_span {
       ...
   }

   We use a for loop to iterate through each byte in the input text's span. In Cairo, when dealing with ASCII strings in a ByteArray, each character is represented as a u8 byte.

3. The Core Logic - Character Processing:

   Inside the loop, we have a crucial if/else if/else block that determines how to handle each character. This is the heart of our implementation.

       ● Start (Receive Character `byte`)
       │
       ▼
     ◆ Is `byte` between 'a' and 'z'?
     ╱           ╲
   Yes            No
    │              │
    ▼              ▼
   ┌──────────────────┐  ◆ Is `byte` between 'A' and 'Z'?
   │ Apply Lowercase  │ ╱           ╲
   │ Rotation Formula │ Yes          No
   └─────────┬────────┘ │            │
             │          ▼            ▼
             │      ┌───────────────┐ ┌───────────────┐
             │      │ Apply Uppercase │ │ Keep Original │
             │      │ Rotation Formula│ │ `byte`        │
             │      └───────┬───────┘ └───────┬───────┘
             └───────────┬──┴───────────────┘
                         │
                         ▼
               ● End (Return Processed `byte`)
   

4. Handling Lowercase Letters:

   if *byte >= 'a' && *byte <= 'z' {
       let char_code: u32 = (*byte).into();
       let base: u32 = 'a'.into();
       
       let wrapped_char = ((char_code - base + key_u32) % 26);
       let new_char_code = base + wrapped_char;
       
       result.append_byte(new_char_code.try_into().unwrap());
   }

   If the byte is a lowercase letter, we perform the rotational logic.

   • We convert the character's ASCII value (e.g., 'a' is 97) and the base 'a' to u32 for safer arithmetic.
   • char_code - base normalizes the value to a 0-25 range (e.g., 'a' becomes 0, 'b' becomes 1).
   • We add the key and use the modulo % 26 operator to handle the "wrap-around".
   • Finally, we add the base back to convert the 0-25 value back to its proper ASCII code.
   • The new character is appended to our result.

5. Handling Uppercase and Other Characters:

   The logic for uppercase letters is identical, but it uses 'A' as its base. For any character that is not an alphabet letter (the final else block), we simply append it to the result unchanged. This ensures that spaces, numbers, and punctuation are preserved in the output.

---

Where, When, and Who: The Context of the Rotational Cipher

Where is this cipher used today?

Let's be clear: the Rotational Cipher is not secure for modern use. It can be broken in seconds using a technique called frequency analysis or even by simply brute-forcing all 25 possible keys. Its value today is almost entirely educational.

You might find it used for:

• Simple Obfuscation: ROT13 is a common convention online to hide movie spoilers or puzzle hints. It's not security; it's a way to prevent accidental viewing.
• Programming Puzzles: It's a classic introductory problem in computer science to teach loops, conditionals, and character manipulation.
• Educational Tool: It's the "Hello, World!" of cryptography, providing a gentle introduction to concepts like keys, plaintext, and ciphertext.

Who benefits from learning this in Cairo?

This module from the kodikra.com curriculum is designed for:

• Aspiring Starknet/Cairo Developers: It provides a practical exercise to get comfortable with Cairo's syntax and data types.
• Students of Cryptography: Implementing even a basic cipher builds foundational knowledge that is critical for understanding more complex systems.
• Problem Solvers: Anyone looking to enhance their algorithmic thinking will benefit from breaking down and solving this classic problem.

Pros and Cons of the Rotational Cipher

To provide a balanced view, here's a summary of its strengths and weaknesses.

Pros	Cons / Risks
Extremely Simple to Implement: The logic is straightforward and requires minimal code.	Completely Insecure: Trivial to break with frequency analysis or brute force.
Fast to Compute: The algorithm is very efficient with a linear time complexity O(n), where n is the length of the message.	Limited Key Space: There are only 25 meaningful keys to try for the English alphabet.
Excellent for Learning: A perfect tool for teaching basic programming and cryptographic concepts.	Preserves Letter Patterns: The structure of the original text (word lengths, double letters) remains, providing clues to attackers.
Reversible: Decryption is as easy as encrypting with a key of 26 - key.	Language Dependent: The classic implementation is tied to a specific alphabet (e.g., English).

---

Frequently Asked Questions (FAQ)

What is the difference between a Rotational Cipher and a Caesar Cipher?

There is no difference. "Caesar Cipher" is the historical name for the technique, specifically referring to Julius Caesar's use of a key of 3. "Rotational Cipher" is the more general, modern term describing the same mechanism of shifting letters in an alphabet.

Why is the key typically between 0 and 26?

Because there are 26 letters in the English alphabet. Due to modular arithmetic (the % 26 operation), any key outside this range will produce the same result as a key within it. For example, a key of 27 is equivalent to a key of 1, and a key of -1 is equivalent to a key of 25.

How do you decrypt a message encrypted with a Rotational Cipher?

Decryption is simply the reverse process. You can either shift the letters backward by the same key or, more easily, perform another rotation using a new key calculated as 26 - original_key. For example, to decrypt a message encrypted with a key of 5, you would re-encrypt it with a key of 21 (26 - 5).

Can this cipher be used for numbers and symbols?

The classic implementation only operates on alphabetic characters and leaves all other characters unchanged. However, the algorithm could be extended to rotate numbers (0-9) or a specific set of symbols, but this would be a custom implementation beyond the standard definition.

Is the Rotational Cipher secure enough for my application?

Absolutely not. You should never, under any circumstances, use this cipher for protecting sensitive information. It is purely for educational purposes. For real-world security, use modern, standardized encryption algorithms like AES (Advanced Encryption Standard).

How does Cairo handle strings in this example?

In this solution, we use ByteArray, which is a dynamic array of bytes (u8). This is a common and flexible way to handle ASCII or UTF-8 string data in Cairo. We interact with it through its span, which gives us a view into its elements, allowing us to iterate over each character/byte.

What is the `felt252` type in Cairo?

felt252 is the native data type in Cairo, representing a field element in a 252-bit prime field. While almost everything in Cairo compiles down to felts, higher-level types like u8, u32, and ByteArray are provided for convenience and safety, as we've used in our solution. For more details, explore our complete Cairo language guide.

---

Conclusion: A Foundational Step in Your Cairo Journey

Mastering the Rotational Cipher in Cairo is more than just an academic exercise. It's a practical milestone that demonstrates your growing command over the language's core features. You've navigated string manipulation with ByteArray, applied careful type conversions, and implemented classic algorithmic logic using Cairo's syntax. This small but significant project builds the muscle memory and conceptual understanding needed for tackling the complex challenges of smart contract development and provable programs.

You've taken a piece of ancient history and brought it to life on the cutting edge of blockchain technology. This foundational skill is a building block you will rely on as you continue to explore more advanced topics in the exclusive kodikra.com Cairo learning path.

Disclaimer: The code in this article is written for Cairo v2.6.x and Scarb v2.6.x. The Cairo language and its ecosystem are rapidly evolving, so syntax and library functions may change in future versions.

---

Published by Kodikra — Your trusted Cairo learning resource.