PD4CS

The rotation cipher is often described using a mathematical formula. First, we start by matching each letter in the alphabet to a number as follows:

A = 0, B = 1, C = 2…Z = 25

The plaintext can then be written as a series of numbers:

Plaintext:                                        P     Y     T     H     O     N

Plaintext as numbers:                   15   24   19    7     14   13

If the key is “R” (or 17), we can encrypt the message by adding the corresponding number to each number in the plaintext.

(15 + 17)        (24 + 17)        (19 + 17)        (7 + 17)          (14 + 17)        (13 + 17)

The problem is that many of these numbers will be greater than 25, which means they will not have a letter to correspond to. Consider, for example, the first letter, which is encrypted as (15 + 17) = 32, which does not correspond to a letter in the alphabet. What we want in this case is for it to go up to Z (25), then loop back around to A (0) and go from there. To do this we use the modulus operator (%). This takes the remainder that you get when you divide two numbers.

(15 + 17) % 26 = 32 % 26 = 6 because 32/26 = 1 remainder 6

So our now our ciphertext becomes:

6          15       10        24       5          4

which corresponds to:

G         P         K         Y         F         E

To decrypt, all we have to do is take the ciphertext values and subtract the key value, remembering include % 26. This leads to the following encryption and decryption formulas where m represents one letter of plaintext, c represents one letter of ciphertext, and k represents the key.

c := (m + k) % 26

m:= (c – k) % 26

So far, the formula is good for encrypting and decrypting messages for which the alphabet goes from 0 to 25. But in programming, the ASCII values for capital letters start at 65. To account for this, we will add and subtract 65 from the values as follows:

c:= (m – 65 + k) % 26 + 65

m:= (c – 65 – k) % 26 + 65

This essentially brings the values down to the 1-25 range, adds or subtracts the key, calculates the new value, then adds 65 again to put it back into ASCII range.

Programming Activity

Part A

• The goal of this project is to write a Python program that will allow them to set up a Rotation Cipher with any key and use it to encrypt and decrypt any messages.
• Two useful functions they will need are ord() and chr(), which change ASCII values to characters and vice versa. For example, ord(‘A’) will yield 65, and chr(65) will yield ‘A’.
• This project can be good practice for classes and objects. Create a class called RotationCipher that has one instance variable (key) and several methods, including the __init__, setKey for changing the key, encrypt, and decrypt. Discuss with the students what each method should do.
• Note: The formula given for encryption and decryption restricts the possible characters to capital letters. This means that any spaces in the plaintext should be removed before encryption.
• Example Code:

#!/usr/bin/python

class RotationCipher:

    def __init__(self, key):
        self.key = ord(key) - 65

    def setKey(self, key):
        self.key = ord(key) - 65

    def encrypt(self, message):
        encrypted = ""
        message = message.replace(" ", "")
        for letter in message:
            encrypted += chr((ord(letter) - 65 + self.key) % 26 + 65)
        return encrypted

    def decrypt(self, message):
        decrypted = ""
        message = message.replace(" ", "")
        for letter in message:
            decrypted += chr((ord(letter) - 65 - self.key) % 26 + 65)
        return decrypted

#This portion is a user interface to interact with the class and methods

RC = RotationCipher("A")
cmd = ""

while cmd != "quit":
    cmd = raw_input(">>")
    if cmd == "setKey":
        key = raw_input("\nKey: ")
        RC.setKey(key)
    elif cmd == "encrypt":
        message = raw_input("\nPlaintext: ")
        CT = RC.encrypt(message)
        print CT
    elif cmd == "decrypt":
        ciphertext = raw_input("\nCiphertext: ")
        PT = RC.decrypt(ciphertext)
        print PT

Part B

• As was mentioned above, the key space for this encryption system is very small (only 26 possibilities in the English alphabet). Even a human, given enough time, would be able to break it by brute-force (for example, using a decoder ring), and a computer could try all 26 possibilities in a very short amount of time.
• The goal of this part is to write a short program to break the cipher. The program should be separate from Part A since someone breaking the cipher should not have access to any of the Rotation Cipher information.
• Discuss with the students how they might go about breaking the cipher, pointing them back to what they did with the decoder rings.
• Give the students a lengthy portion of ciphertext, and ask them to write a program to break it. If they come up with the correct plaintext (and the key), then their code is probably right.
• Example Code:

#!/usr/bin/python

ciphertext = raw_input("Enter the ciphertext: ")
key = 0

ciphertext = ciphertext.replace(" ", "")

while key < 26:
    message = ""
    for letter in ciphertext:
        message += chr((ord(letter) - 65 - key) % 26 + 65)
    print message + "\n"
    key += 1