Cybersecuritycryptographyciphersecurity

Shift Cipher Implementation

Implementation of shift cipher for both printable ASCII and binary input with encryption and decryption capabilities.

Date

2024

Overview

Lab 1 project implementing the classic shift cipher (Caesar cipher) algorithm for both printable ASCII characters and binary data. The implementation demonstrates fundamental cryptographic concepts including modular arithmetic, character encoding, and basic encryption/decryption workflows. Includes a flag-finding challenge component that applies cipher-breaking techniques.

As part of this exercise, we were tasked with implementing a Shift Cipher encryption and decryption program in Python. The goal was to read a given text file, apply a shift cipher using a specified key, and produce an encrypted (or decrypted) output file depending on the selected mode.

The input text file, sherlock.txt, contained the following excerpt from a Sherlock Holmes novel:

sherlock.txt

Mr. Sherlock Holmes, who was usually very late in the mornings, save
upon those not infrequent occasions when he was up all night, was seated at the breakfast table.

We had to write a Python program (ex1.py) that could:

Load a given .txt file.
Encrypt it with a specified key.
Output the encrypted (ciphered) text.
Provide a decryption mode to reverse the process.

Technologies Used

PythonCryptographyASCII EncodingModular Arithmetic

Key Features

Shift cipher encryption for printable ASCII input

Binary shift cipher implementation

Encryption and decryption functions

Flag finding challenge solver

Brute force attack implementation

Frequency analysis tools

Showing 6 of 7 features

Implementation Details

Command-Line Argument Validation

The program is executed using the following command-line format:

Terminal

python3 ex1.py -i [input filename] -o [output filename] -k [key] -m [mode]

Before performing any encryption or decryption, the program first checks that all required command-line arguments are provided. This ensures that the user has correctly specified the input/output filenames, key, and mode. This validation prevents runtime errors and ensures that users follow the proper command format before the program proceeds.

ex1.py

# Check if all required arguments are provided
if len(sys.argv) != 9:
    print("Usage: python3 ex1.py -i [input] -o [output] -k [key] -m [mode]")
    sys.exit(1)

# Parse command-line arguments
args = {}
for i in range(1, len(sys.argv), 2):
    args[sys.argv[i]] = sys.argv[i + 1]

# Validate all required flags are present
required_flags = ['-i', '-o', '-k', '-m']
for flag in required_flags:
    if flag not in args:
        print(f"Error: Missing required argument {flag}")
        sys.exit(1)

input_file = args['-i']
output_file = args['-o']
key = int(args['-k'])
mode = args['-m'].lower()

# Validate mode
if mode not in ['encrypt', 'decrypt']:
    print("Error: Mode must be 'encrypt' or 'decrypt'")
    sys.exit(1)

Code Explanation

The code first checks if exactly 9 arguments are provided (program name + 8 arguments for 4 flags). It then parses these arguments into a dictionary for easy access. Next, it validates that all required flags (-i, -o, -k, -m) are present. Finally, it validates that the mode is either "encrypt" or "decrypt". This comprehensive validation ensures the program won't crash due to missing or invalid input.

File Validation and Loading

Next, we ensure that the input file exists and can be read properly. Two helper functions are used: 1. To check whether the .txt file exists. 2. To confirm that the file contains printable characters only.

These checks prevent the program from crashing on missing or corrupted files, ensuring the text is valid before encryption.

ex1.py

import os

def file_exists(filename):
    """Check if a file exists"""
    return os.path.isfile(filename)

def is_printable_file(filename):
    """Check if file contains only printable ASCII characters"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            content = f.read()
            # Check if all characters are printable (ASCII 32-126)
            for char in content:
                if ord(char) < 32 or ord(char) > 126:
                    if char not in ['\n', '\r', '\t']:  # Allow newlines and tabs
                        return False
            return True
    except Exception as e:
        print(f"Error reading file: {e}")
        return False

def load_file(filename):
    """Load and return file contents"""
    if not file_exists(filename):
        print(f"Error: File '{filename}' not found")
        sys.exit(1)

    if not is_printable_file(filename):
        print(f"Error: File '{filename}' contains non-printable characters")
        sys.exit(1)

    with open(filename, 'r', encoding='utf-8') as f:
        return f.read()

# Load the input file
text = load_file(input_file)

Code Explanation

The file_exists() function uses os.path.isfile() to verify the file exists. The is_printable_file() function reads the file and checks each character to ensure it falls within the printable ASCII range (32-126), with exceptions for newlines, carriage returns, and tabs. The load_file() function combines these checks and returns the file contents only if all validations pass. This prevents the cipher from processing invalid input data.

Shift Cipher Encryption and Decryption

The Shift Cipher (also known as the Caesar Cipher) works by shifting each printable character by a given key value along the ASCII range. If the shift goes beyond the printable range, it wraps around to the start.

In encryption mode, characters are shifted forward by key. In decryption mode, characters are shifted backward by key.

This ensures full reversibility — decrypting the encrypted output with the same key restores the original text.

ex1.py

def shift_cipher(text, key, mode):
    """
    Apply shift cipher to text

    Args:
        text: Input text to encrypt/decrypt
        key: Shift amount
        mode: 'encrypt' or 'decrypt'

    Returns:
        Transformed text
    """
    # Define the printable ASCII range
    MIN_PRINTABLE = 32  # Space character
    MAX_PRINTABLE = 126  # Tilde character
    RANGE = MAX_PRINTABLE - MIN_PRINTABLE + 1  # 95 printable characters

    result = []

    for char in text:
        # Get ASCII value
        ascii_val = ord(char)

        # Skip non-printable characters (newlines, etc.)
        if ascii_val < MIN_PRINTABLE or ascii_val > MAX_PRINTABLE:
            result.append(char)
            continue

        # Normalize to 0-94 range
        normalized = ascii_val - MIN_PRINTABLE

        # Apply shift based on mode
        if mode == 'encrypt':
            shifted = (normalized + key) % RANGE
        else:  # decrypt
            shifted = (normalized - key) % RANGE

        # Convert back to ASCII
        new_ascii = shifted + MIN_PRINTABLE
        result.append(chr(new_ascii))

    return ''.join(result)

# Apply the cipher
if mode == 'encrypt':
    output_text = shift_cipher(text, key, 'encrypt')
else:
    output_text = shift_cipher(text, key, 'decrypt')

# Write output to file
with open(output_file, 'w', encoding='utf-8') as f:
    f.write(output_text)

print(f"Successfully {mode}ed '{input_file}' to '{output_file}' with key {key}")

Code Explanation

The shift_cipher() function implements the core algorithm. It defines the printable ASCII range (32-126, giving 95 characters). For each character, it: 1. Gets the ASCII value using ord() 2. Normalizes it to 0-94 range by subtracting MIN_PRINTABLE 3. Applies the shift using modulo arithmetic to handle wraparound 4. For encryption: (normalized + key) % 95 5. For decryption: (normalized - key) % 95 6. Converts back to ASCII by adding MIN_PRINTABLE and using chr() The modulo operation ensures that if a shift goes beyond 126, it wraps back to 32, maintaining the cipher within the printable range. This makes the cipher fully reversible - encrypting with key K and then decrypting with the same key K returns the original text.

Shift Cipher for Binary Input

We now need to attempt shift cipher with binary files instead of just printable text outputs. This allows us to encrypt any type of file - images, executables, compressed files, etc.

Using the same command-line interface and validation as above, this time instead of just shifting over printable ASCII characters, we work directly with raw bytes. The implementation converts bytes to a formatted hex string for visualization and applies the shift to each byte value:

ex2.py

def bytes_to_hex_string(data):
    """Convert bytes to a formatted hex string with ASCII representation."""
    result = []

    for i in range(0, len(data), 16):
        # Get current 16 bytes
        chunk = data[i:i+16]

        # Create hex representation
        hex_line = ' '.join(f'{b:02x}' for b in chunk)
        hex_line = f'{hex_line:<48}'  # Pad with spaces to align ASCII

        # Create ASCII representation
        ascii_line = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in chunk)

        # Add offset
        line = f'{i:08x}  {hex_line}  |{ascii_line}|'
        result.append(line)

    return 'Offset    00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  |ASCII|\n' + \
           '-' * 75 + '\n' + \
           '\n'.join(result)

def encrypt(data, key):
    """Encrypt the bytes using the given key."""
    result = bytearray()
    for byte in data:
        # Add key and wrap around using modulo 256 (for 8-bit arithmetic)
        encrypted_byte = (byte + key) % 256
        result.append(encrypted_byte)
    return bytes(result)

def decrypt(data, key):
    """Decrypt the bytes using the given key."""
    result = bytearray()
    for byte in data:
        # Subtract key and wrap around using modulo 256 (for 8-bit arithmetic)
        decrypted_byte = (byte - key) % 256
        result.append(decrypted_byte)
    return bytes(result)

# Read input file in binary mode
with open(input_file, 'rb') as f:
    data = f.read()

# Process the data
if mode == 'e':
    result = encrypt(data, args.key)
else:
    result = decrypt(data, args.key)

# Write output file in binary mode
with open(output_file, 'wb') as f:
    f.write(result)

# Write hex representation to txt file
with open(output_txt_file, 'w') as f:
    f.write(bytes_to_hex_string(result))

Code Explanation

The binary shift cipher works at the byte level rather than character level: 1. **bytes_to_hex_string()**: Creates a hex dump visualization similar to tools like hexdump or xxd. It displays bytes in hexadecimal with their ASCII representation, making it easy to inspect binary data. 2. **encrypt()/decrypt()**: These functions operate on raw bytes (0-255) instead of printable ASCII (32-126). Each byte is shifted using modulo 256 arithmetic: - Encryption: (byte + key) % 256 - Decryption: (byte - key) % 256 3. **Binary file handling**: Files are opened with 'rb' (read binary) and 'wb' (write binary) modes to handle any file type, not just text. 4. **Output**: Two files are generated: - The encrypted/decrypted binary file (same format as input) - A .txt file with hex dump for analysis This approach works on ANY file type because it operates at the byte level. An encrypted image remains a valid image format (though visually scrambled), and can be perfectly restored by decryption. The 8-bit arithmetic (0-255 range) ensures all byte values remain valid after transformation.

Challenges

Understanding modular arithmetic for wraparound behavior, handling edge cases in ASCII encoding, implementing efficient brute force attack strategies for cipher breaking.

Outcome & Impact

Successfully implemented robust shift cipher with both ASCII and binary support, demonstrated cipher vulnerability through brute force analysis.

How I Grew

Mastered fundamental concepts of symmetric encryption

Learned modular arithmetic applications in cryptography

Understood the weakness of simple substitution ciphers

Gained experience in cipher breaking techniques

Developed skills in handling different encoding schemes

Try It Yourself

Input

Output

Output will appear here...

Works with letters, numbers, and special characters. Try "Hello World!" with key 3.

All Projects Learn More About Me