Affine Cipher in Bash: The Ultimate Guide to Scripting Ancient Encryption

The Affine Cipher is a classic monoalphabetic substitution cipher that enhances the Caesar cipher by using a linear function. This guide explains its mathematical foundation and provides a complete, robust Bash script to perform both encryption and decryption, making it a perfect project for sharpening your scripting skills.

The Agonizing Quest for a Better Secret Code

Imagine you're a budding cryptographer, tired of simple letter-swapping games. You've mastered the Caesar cipher, shifting letters by a fixed amount, but you quickly realize its weakness. With only 25 possible keys, anyone can break your "secret" message in minutes with brute force. You need something more complex, something with more mathematical elegance to truly challenge a codebreaker.

This is the exact problem that ancient mathematicians and cryptographers faced. They needed a system that was easy enough to use by hand but significantly harder to crack than a simple shift. Their solution was a beautiful application of modular arithmetic: the Affine Cipher. It introduces a second key, a multiplier, that scrambles the letters in a far less predictable way. This guide will not only demystify the math behind it but empower you to build your own implementation from scratch using the versatile power of Bash scripting.

What Is the Affine Cipher? A Mathematical Deep Dive

The Affine Cipher is a type of monoalphabetic substitution cipher. This means each letter of the alphabet is mapped to exactly one other letter. Its strength lies in its use of a linear mathematical function to perform this mapping, making it a significant step up from ciphers that only use addition (like Caesar).

The core of the cipher lies in two keys, typically denoted as a and b, and a simple formula.

The Encryption Formula: E(x) = (ax + b) mod m

Let's break down this elegant equation:

• x: Represents the numeric value of a plaintext letter (e.g., a=0, b=1, c=2, ..., z=25).
• a: The first key, known as the multiplier. This value multiplies the letter's numeric value, spreading the letters out across the alphabet.
• b: The second key, known as the shift or offset. This value is added after the multiplication, similar to a Caesar cipher shift.
• m: The size of the alphabet. For the English alphabet, m is 26.
• mod m: The modulo operator, which ensures the result wraps around and stays within the alphabet's bounds (0 to 25).

The most critical rule governs the key a. For the cipher to be decryptable, a must be coprime with m. This means their greatest common divisor (GCD) must be 1 (i.e., gcd(a, 26) = 1). If this condition isn't met, multiple plaintext letters could map to the same ciphertext letter, making it impossible to reverse the process uniquely.

For an alphabet of size 26, the valid values for a are: 1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, and 25.

The Decryption Formula: D(y) = a⁻¹(y - b) mod m

Decrypting an Affine Cipher message requires reversing the encryption process. This involves subtraction, but more importantly, it requires division. In modular arithmetic, we don't divide; we multiply by the modular multiplicative inverse.

• y: Represents the numeric value of a ciphertext letter.
• a⁻¹: This is the modular multiplicative inverse of a modulo m. It's a number such that (a * a⁻¹) mod m = 1. Finding this inverse is the key to unlocking the message.
• (y - b): This reverses the addition of the shift key b.

The entire process hinges on being able to find a⁻¹, which is only possible if a and m are coprime. This mathematical constraint is the heart of the cipher's design.

How to Implement the Affine Cipher in Bash

Building an Affine Cipher script in Bash is an excellent exercise in handling string manipulation, arithmetic operations, and algorithmic logic. We will create a robust script that can validate keys, encode plaintext, and decode ciphertext.

The Logic Flow: Encryption vs. Decryption

Before diving into the code, let's visualize the two main processes. Understanding the flow is crucial for writing clean and effective code.

Encryption Process Diagram

This diagram illustrates how a single character of plaintext is transformed into a ciphertext character.

    ● Start with Plaintext Character
    │
    ▼
  ┌───────────────────────────┐
  │  Convert Char to 0-Index  │
  │  (e.g., 'c' ⟶ 2)          │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Apply Encryption Formula  │
  │   y = (a * x + b) % 26    │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Convert New Index to Char │
  │  (e.g., 15 ⟶ 'p')         │
  └────────────┬──────────────┘
               │
               ▼
    ● End with Ciphertext Character

Decryption Process Diagram

Decryption is the reverse, with the critical step of first finding the modular multiplicative inverse (MMI) of the key a.

    ● Start with Ciphertext Character
    │
    ▼
  ┌───────────────────────────┐
  │  Convert Char to 0-Index  │
  │  (e.g., 'p' ⟶ 15)         │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Find Modular Inverse (a⁻¹)│
  │   (a * a⁻¹) % 26 = 1      │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Apply Decryption Formula  │
  │ x = a⁻¹ * (y - b) % 26    │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Convert Old Index to Char │
  │  (e.g., 2 ⟶ 'c')          │
  └────────────┬──────────────┘
               │
               ▼
    ● End with Plaintext Character

The Complete Bash Script

Here is a full-featured Bash script that implements the Affine Cipher. It includes key validation, encoding, decoding, and helper functions for the required mathematical operations. This script is designed for clarity and can be saved as affine_cipher.sh.

#!/usr/bin/env bash

# affine_cipher.sh
# A script to encrypt and decrypt text using the Affine Cipher.
# This script is part of the exclusive kodikra.com learning curriculum.

set -euo pipefail

# --- Global Variables ---
readonly ALPHABET="abcdefghijklmnopqrstuvwxyz"
readonly M=26 # Size of the alphabet

# --- Helper Functions ---

# Calculates the greatest common divisor (GCD) of two numbers using Euclidean algorithm.
# Usage: gcd  
gcd() {
    local a=$1
    local b=$2
    local temp
    while (( b != 0 )); do
        temp=$b
        b=$(( a % b ))
        a=$temp
    done
    echo "$a"
}

# Finds the modular multiplicative inverse (MMI) of 'a' modulo 'm'.
# It searches for a number 'n' such that (a * n) % m == 1.
# Usage: find_mmi  
find_mmi() {
    local a=$1
    local m=$2
    for ((n = 1; n < m; n++)); do
        if ((( (a * n) % m ) == 1 )); then
            echo "$n"
            return 0
        fi
    done
    # This should not be reached if 'a' is valid
    echo "Error: MMI not found for a=$a" >&2
    return 1
}

# Cleans input text: converts to lowercase and removes non-alphanumeric characters.
# Usage: clean_text "Some Text!"
clean_text() {
    echo "$1" | tr '[:upper:]' '[:lower:]' | tr -dc 'a-z0-9'
}

# --- Core Cipher Functions ---

# Encodes a plaintext string using the Affine Cipher.
# Usage: encode   "plaintext"
encode() {
    local a=$1
    local b=$2
    local plaintext
    plaintext=$(clean_text "$3")
    local ciphertext=""
    local result=""

    for (( i=0; i<${#plaintext}; i++ )); do
        local char="${plaintext:i:1}"
        if [[ "$char" =~ [a-z] ]]; then
            # It's a letter, encrypt it
            local x
            # Get the 0-based index of the character
            x=$(tr -d -c "$char" <<< "$ALPHABET" | wc -c)
            x=$((x - 1))
            
            local y=$(( (a * x + b) % M ))
            ciphertext+="${ALPHABET:y:1}"
        elif [[ "$char" =~ [0-9] ]]; then
            # It's a number, keep it as is
            ciphertext+="$char"
        fi
    done

    # Group output into blocks of 5 characters for readability
    result=$(echo "$ciphertext" | fold -w 5 | paste -sd ' ' -)
    echo "$result"
}

# Decodes a ciphertext string using the Affine Cipher.
# Usage: decode   "ciphertext"
decode() {
    local a=$1
    local b=$2
    local ciphertext
    # Remove spaces for processing
    ciphertext=$(echo "$3" | tr -d ' ')
    local plaintext=""
    
    local mmi
    mmi=$(find_mmi "$a" "$M")

    for (( i=0; i<${#ciphertext}; i++ )); do
        local char="${ciphertext:i:1}"
        if [[ "$char" =~ [a-z] ]]; then
            # It's a letter, decrypt it
            local y
            y=$(tr -d -c "$char" <<< "$ALPHABET" | wc -c)
            y=$((y - 1))

            # Apply decryption formula: x = mmi * (y - b) % M
            # The `+ M` handles potential negative results from (y - b)
            local x=$(( (mmi * (y - b) + M) % M ))
            plaintext+="${ALPHABET:x:1}"
        elif [[ "$char" =~ [0-9] ]]; then
            # It's a number, keep it as is
            plaintext+="$char"
        fi
    done

    echo "$plaintext"
}

# --- Main Script Logic ---

main() {
    if (( $# != 4 )); then
        echo "Usage: $0 <encode|decode> <a> <b> \"<text>\"" >&2
        exit 1
    fi

    local action=$1
    local a=$2
    local b=$3
    local text=$4

    # Validate key 'a'
    if (( $(gcd "$a" "$M") != 1 )); then
        echo "Error: key 'a' ($a) must be coprime with alphabet size ($M)." >&2
        exit 1
    fi

    case "$action" in
        encode)
            encode "$a" "$b" "$text"
            ;;
        decode)
            decode "$a" "$b" "$text"
            ;;
        *)
            echo "Error: Invalid action. Choose 'encode' or 'decode'." >&2
            exit 1
            ;;
    esac
}

# Execute the main function with all script arguments
main "$@"

set -euo pipefail

readonly ALPHABET="abcdefghijklmnopqrstuvwxyz"
readonly M=26

# Calculates the greatest common divisor (GCD)
gcd() { ... }

# Finds the modular multiplicative inverse (MMI)
find_mmi() { ... }

encode() {
    local a=$1
    local b=$2
    local plaintext=$(clean_text "$3")
    # ... loop ...
}

decode() {
    local a=$1
    local b=$2
    # ...
    local mmi=$(find_mmi "$a" "$M")
    # ... loop ...
}

main() {
    if (( $# != 4 )); then ... fi

    # ... argument parsing ...

    if (( $(gcd "$a" "$M") != 1 )); then
        echo "Error: key 'a' ($a) must be coprime with alphabet size ($M)." >&2
        exit 1
    fi

    case "$action" in ... esac
}

main "$@"

# Make the script executable
chmod +x affine_cipher.sh

# --- Example Usage ---

# Encode a message with key a=5, b=7
# Plaintext: "thequickbrownfoxjumpsoverthelazydog"
./affine_cipher.sh encode 5 7 "The quick brown fox jumps over the lazy dog."
# Expected Output: fqjcb rwjwj vnjax bncha djhjd majsq dsubd jbjsw jaxee jaxvb j

# Decode the message with the same key
./affine_cipher.sh decode 5 7 "fqjcb rwjwj vnjax bncha djhjd majsq dsubd jbjsw jaxee jaxvb j"
# Expected Output: thequickbrownfoxjumpsoverthelazydog