One-time pad cipher

One time pad Cipher

The one-time pad (OTP) is a unique encryption technique known for its theoretical perfect secrecy. Here's a breakdown of its key aspects:

Definition:

• OTP is a symmetric cipher that encrypts information using a random key that's the same length as the message itself.
• This one-time use of the key is crucial for its security.

How it Works:

1. Key Generation: A truly random key is generated, with each character being random (often bits 0 and 1). The key length needs to be equal to or greater than the message you want to encrypt.
2. Encryption: The message (plaintext) is then combined with the key using a bitwise XOR operation. XOR essentially flips bits whenever the corresponding bits are different.
   • Example (assuming binary):
     • Plaintext bit: 1 0 1 0 1
     • Key bit: 0 1 0 1 0
     • Ciphertext bit: 1 1 1 1 1
3. Decryption: The ciphertext is XORed with the same key used for encryption, recovering the original message.

Security:

• When the one-time pad is used correctly, it's mathematically impossible to crack the cipher. This is because the ciphertext contains no statistical correlation to the original message.
• However, security hinges on these strict conditions:
  • True randomness: The key needs to be genuinely random, with no patterns or predictability.
  • One-time use: The same key must never be used for more than one message. Reusing a key compromises security.

Applications (Limited):

• Due to the impracticalities of sharing and managing long, random keys, OTP has niche applications.
• It's sometimes used for highly sensitive information exchange where perfect secrecy is paramount.
• OTP can also play a role in quantum key distribution (QKD) for generating secure keys.

In essence, the one-time pad offers unbreakable encryption, but its real-world use is restricted by key management challenges. 

Python code:

import os

def generate_key(length):

    return os.urandom(length)

 

def one_time_pad(text, key):

    text_bytes = text.encode()

    encrypted_bytes = bytes([b ^ k for b, k in zip(text_bytes, key)])

    return encrypted_bytes

 

def decrypt_one_time_pad(encrypted_bytes, key):

    decrypted_bytes = bytes([b ^ k for b, k in zip(encrypted_bytes, key)])

    return decrypted_bytes.decode()

 

# Usage

message = "HELLO, WORLD!"

key = generate_key(len(message))

 

encrypted_message = one_time_pad(message, key)

decrypted_message = decrypt_one_time_pad(encrypted_message, key)

 

print(f"Encrypted (in bytes): {encrypted_message}")

print(f"Decrypted: {decrypted_message}")

Also see:

ceaser cipher

Vigenere Cipher