Monoalphabetic Substitution and Vernam

A monoalphabetic substitution replaces each plaintext symbol with a fixed corresponding ciphertext symbol. To decrypt unambiguously over the chosen alphabet, use a one-to-one permutation: every symbol has exactly one inverse. A Caesar shift is one special case, but a general permutation need not move every letter by the same distance.

The example uses uppercase ASCII A–Z only and key QWERTYUIOPASDFGHJKLZXCVBNM in plaintext-alphabet order. B maps to W, A to Q and D to R, so BAD encrypts as WQR. Repeated plaintext letters still produce repeated ciphertext letters, revealing patterns. A large number of possible substitution keys does not erase the statistical structure of an ordinary language message.

The code rejects a key that omits or duplicates an alphabet symbol and rejects input outside its stated alphabet. Decryption reverses the mapping, not the ciphertext string. Spaces, punctuation and lowercase text would need an explicitly extended input policy; silently dropping them would lose information. The example’s restrictions make the reversible domain visible.

Test all twenty-six individual symbols and a whole alphabet round trip. A valid permutation should recover every permitted message exactly. A wrong but reversible mapping can still pass a self-consistent round trip, so also check independent known substitutions such as BAD→WQR. Neither the code nor this key is offered as modern secure storage or communication.

ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def substitute(text, key, decrypt=False):
    if len(key) != 26 or set(key) != set(ALPHABET):
        raise ValueError('Key must be a permutation of uppercase A-Z')
    if any(character not in ALPHABET for character in text):
        raise ValueError('Use uppercase A-Z input only')
    source, target = (key, ALPHABET) if decrypt else (ALPHABET, key)
    mapping = dict(zip(source, target))
    return ''.join(mapping[character] for character in text)

key = 'QWERTYUIOPASDFGHJKLZXCVBNM'
ciphertext = substitute('BAD', key)
print(ciphertext)
print(substitute(ciphertext, key, decrypt=True))

A Vernam XOR mechanism combines matching plaintext/key bits. Repeating XOR with the same key recovers the original because x XOR k XOR k=x. For bits 1001 and key 0110, ciphertext is 1111; applying 0110 again gives 1001. The byte example uses two fixed teaching key bytes to make the arithmetic reproducible.

Perfect-secrecy one-time-pad reasoning needs an independently uniformly random secret key at least as long as the message and no reuse, with the scheme used correctly. XOR alone does not create those properties. Reusing the same pad across two messages leaks a relationship between their plaintexts, and XOR encryption alone does not provide message authentication. Keep text encoding, byte values and the key assumptions separate.

def xor_bytes(data, key):
    if len(data) != len(key):
        raise ValueError('Data and key must have equal length')
    return bytes(value ^ mask for value, mask in zip(data, key))

plaintext = b'HI'
key = bytes([42, 7])
ciphertext = xor_bytes(plaintext, key)
print(list(ciphertext))
print(xor_bytes(ciphertext, key).decode('ascii'))

Attempt the task before opening its worked response. Record each change of state, explain the rule used, and check the result against the original requirements. Code examples labelled Python 3 use that language’s conventions; pseudocode states its own assumptions.