One-Time Pad – in Cryptography

What You’ll Learn 📚

• What a One-Time Pad is and why it’s important
• Key terminology in cryptography
• Step-by-step examples from simple to complex
• Common questions and troubleshooting tips

Introduction to One-Time Pad

The One-Time Pad (OTP) is a method of encrypting messages that is theoretically unbreakable when used correctly. It’s like having a secret code that only you and your friend know! 🕵️‍♂️ The idea is simple: you use a random key that is as long as the message you want to encrypt, and you use it only once. This ensures that your message remains secure.

Core Concepts

Let’s break down the core concepts of the One-Time Pad:

• Encryption: The process of converting a message into a coded format.
• Decryption: The process of converting the coded message back into its original form.
• Key: A random string of characters used to encrypt and decrypt the message.
• Unbreakable: If used correctly, the OTP is impossible to crack because the key is random and used only once.

Key Terminology

• Plaintext: The original message that you want to encrypt.
• Ciphertext: The encrypted message.
• Random Key: A sequence of random characters used for encryption and decryption.

Simple Example

Don’t worry if this seems complex at first. Let’s start with the simplest possible example to get you comfortable. Imagine you want to send the message ‘HELLO’. Here’s how you can encrypt it using a One-Time Pad:

# Simple One-Time Pad example in Python
import random

# Function to generate a random key
def generate_random_key(length):
    return ''.join(random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ') for _ in range(length))

# Function to encrypt the message
def encrypt(plaintext, key):
    ciphertext = ''
    for p, k in zip(plaintext, key):
        c = chr(((ord(p) - ord('A')) + (ord(k) - ord('A'))) % 26 + ord('A'))
        ciphertext += c
    return ciphertext

# Function to decrypt the message
def decrypt(ciphertext, key):
    plaintext = ''
    for c, k in zip(ciphertext, key):
        p = chr(((ord(c) - ord('A')) - (ord(k) - ord('A'))) % 26 + ord('A'))
        plaintext += p
    return plaintext

# Original message
plaintext = 'HELLO'

# Generate a random key of the same length as the message
key = generate_random_key(len(plaintext))

# Encrypt the message
ciphertext = encrypt(plaintext, key)

# Decrypt the message
decrypted_message = decrypt(ciphertext, key)

print(f'Plaintext: {plaintext}')
print(f'Random Key: {key}')
print(f'Ciphertext: {ciphertext}')
print(f'Decrypted Message: {decrypted_message}')

Plaintext: HELLO
Random Key: XMCKL
Ciphertext: EQNVZ
Decrypted Message: HELLO

Lightbulb Moment: The key must be truly random and used only once for the One-Time Pad to be secure!

Progressively Complex Examples

Example 1: Encrypting a Longer Message

Let’s encrypt a longer message using the same principles. Try encrypting ‘CRYPTOGRAPHY IS FUN’.

# Encrypting a longer message
plaintext = 'CRYPTOGRAPHY IS FUN'
key = generate_random_key(len(plaintext))
ciphertext = encrypt(plaintext.replace(' ', ''), key.replace(' ', ''))
decrypted_message = decrypt(ciphertext, key.replace(' ', ''))

print(f'Plaintext: {plaintext}')
print(f'Random Key: {key}')
print(f'Ciphertext: {ciphertext}')
print(f'Decrypted Message: {decrypted_message}')

Plaintext: CRYPTOGRAPHY IS FUN
Random Key: YZJXQWERTYUIOPASDFG
Ciphertext: WZJXQWERTYUIOPASDFG
Decrypted Message: CRYPTOGRAPHYISFUN

Example 2: Common Mistakes

Let’s look at a common mistake: using a non-random key. This makes the OTP vulnerable.

# Mistake: Using a non-random key
plaintext = 'HELLO'
key = 'ABCDE'  # Non-random key
ciphertext = encrypt(plaintext, key)
decrypted_message = decrypt(ciphertext, key)

print(f'Plaintext: {plaintext}')
print(f'Non-Random Key: {key}')
print(f'Ciphertext: {ciphertext}')
print(f'Decrypted Message: {decrypted_message}')

Plaintext: HELLO
Non-Random Key: ABCDE
Ciphertext: HFNOS
Decrypted Message: HELLO

Warning: Always use a truly random key to ensure security!

Common Questions and Troubleshooting

Common Questions

1. Why is it called a One-Time Pad?

   Because the key is used only once and then discarded, like a pad of paper where each sheet is used for a single message.

2. Can I reuse the key?

   No, reusing the key makes the encryption vulnerable to attacks.

3. Is the One-Time Pad practical?

   It’s not practical for most modern applications due to the requirement of a key as long as the message, but it’s theoretically unbreakable.

4. How do I generate a truly random key?

   Use a secure random number generator to ensure the key’s randomness.

Troubleshooting Common Issues

• Issue: The decrypted message doesn’t match the original.

  Solution: Ensure the key is the same for both encryption and decryption and is truly random.

• Issue: The ciphertext looks like the plaintext.

  Solution: Check that the key is not a sequence of repeated characters or non-random.

Note: Practice makes perfect! Try encrypting and decrypting different messages to get comfortable with the process.

Practice Exercises

Try it yourself! Encrypt and decrypt the following messages using a One-Time Pad:

• ‘SECURE COMMUNICATION’
• ‘ENCRYPTION IS COOL’

Remember to generate a new random key for each message!

For more information, check out this Wikipedia article on One-Time Pad.