One-Time Pad Cipher - Problem

Implement a one-time pad cipher system that provides perfect secrecy through cryptographically secure encryption and decryption.

A one-time pad cipher uses a random key that is:

At least as long as the plaintext
Used only once
Kept completely secret
Truly random

The cipher works by performing XOR operations between the plaintext and the key for encryption, and between the ciphertext and the same key for decryption.

Your task is to implement three functions:

generateKey(length) - Generate a cryptographically secure random key
encrypt(plaintext, key) - Encrypt plaintext using the key
decrypt(ciphertext, key) - Decrypt ciphertext using the key

Input Format:

Operation type: "generate", "encrypt", or "decrypt"
For generate: length of key needed
For encrypt: plaintext string and key
For decrypt: ciphertext (as hex string) and key

Output Format:

For generate: random key as hex string
For encrypt: ciphertext as hex string
For decrypt: original plaintext string

Input & Output

Example 1 — Key Generation

$ Input: operation = "generate", data1 = "5", data2 = ""

› Output: "a3f7c9b2d8"

💡 Note: Generate a 5-byte random key, output as hex string (10 characters). Each byte becomes 2 hex digits.

Example 2 — Encryption

$ Input: operation = "encrypt", data1 = "HI", data2 = "a3f7"

› Output: "ebda"

💡 Note: Encrypt 'HI': H(0x48) XOR 0xa3 = 0xeb, I(0x49) XOR 0xf7 = 0xbe. Wait, let me recalculate: H(72) XOR 163 = 235 = 0xeb, I(73) XOR 247 = 182 = 0xb6. So output should be 'ebb6'.

Example 3 — Decryption

$ Input: operation = "decrypt", data1 = "ebb6", data2 = "a3f7"

› Output: "HI"

💡 Note: Decrypt 'ebb6': 0xeb XOR 0xa3 = 0x48 (H), 0xb6 XOR 0xf7 = 0x49 (I). Original plaintext restored.

Constraints

1 ≤ key length ≤ 1000
1 ≤ message length ≤ 1000
Key must be at least as long as message
All hex inputs must be valid hexadecimal strings

Visualization

Tap to expand

Asked in

P Palantir 15 NG Northrop Grumman 12 R Raytheon 10 LM Lockheed Martin 8

The one-time pad cipher provides perfect secrecy through XOR operations with truly random keys. The key insight is using cryptographically secure random generation and ensuring the key is at least as long as the message. Best approach uses secure random sources: Time O(n), Space O(n).

Common Approaches

✓ Cryptographically Secure Implementation

⏱️ Time: O(n) Space: O(n)

Uses cryptographically secure random number generation and proper key management. Implements true one-time pad properties with secure random sources for real-world cryptographic applications.

Weak Random Key Generation

⏱️ Time: O(n) Space: O(n)

Uses basic random number generation and simple XOR operations. While functional, this approach may not provide cryptographically secure randomness suitable for real-world security applications.

Cryptographically Secure Implementation — Algorithm Steps

Generate cryptographically secure random key
Perform XOR encryption with proper padding
Handle decryption with key validation
Ensure key length matches message length

Visualization

Tap to expand

Step-by-Step Walkthrough

Secure Key Generation

Use cryptographic RNG for true randomness

Key Length Validation

Ensure key is at least as long as message

XOR with Error Handling

Perform encryption/decryption with validation

Secure Result

Output with cryptographic guarantees

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

char* solution(char* operation, char* data1, char* data2) {
    if (strcmp(operation, "generate") == 0) {
        int length = atoi(data1);
        char* key = malloc(length * 2 + 1);
        // Use better random seeding
        srand(time(NULL) ^ (unsigned int)&key);
        for (int i = 0; i < length; i++) {
            // Use multiple random calls for better entropy
            int byte_val = (rand() ^ (rand() << 8)) % 256;
            sprintf(key + i * 2, "%02x", byte_val);
        }
        key[length * 2] = '\0';
        return key;
    } else if (strcmp(operation, "encrypt") == 0) {
        char* plaintext = data1;
        char* key = data2;
        int len = strlen(plaintext);
        if (strlen(key) < len * 2) {
            char* error = malloc(20);
            strcpy(error, "ERROR: Key too short");
            return error;
        }
        char* result = malloc(len * 2 + 1);
        for (int i = 0; i < len; i++) {
            char keyHex[3] = {key[i * 2], key[i * 2 + 1], '\0'};
            int keyByte = (int)strtol(keyHex, NULL, 16);
            int encrypted = plaintext[i] ^ keyByte;
            sprintf(result + i * 2, "%02x", encrypted);
        }
        result[len * 2] = '\0';
        return result;
    } else if (strcmp(operation, "decrypt") == 0) {
        char* ciphertext = data1;
        char* key = data2;
        int len = strlen(ciphertext) / 2;
        if (strlen(key) < strlen(ciphertext)) {
            char* error = malloc(20);
            strcpy(error, "ERROR: Key too short");
            return error;
        }
        char* result = malloc(len + 1);
        for (int i = 0; i < len; i++) {
            char cipherHex[3] = {ciphertext[i * 2], ciphertext[i * 2 + 1], '\0'};
            char keyHex[3] = {key[i * 2], key[i * 2 + 1], '\0'};
            int cipherByte = (int)strtol(cipherHex, NULL, 16);
            int keyByte = (int)strtol(keyHex, NULL, 16);
            result[i] = cipherByte ^ keyByte;
        }
        result[len] = '\0';
        return result;
    }
    return NULL;
}

int main() {
    char operation[20], data1[1000], data2[1000];
    fgets(operation, sizeof(operation), stdin);
    operation[strcspn(operation, "\n")] = 0;
    fgets(data1, sizeof(data1), stdin);
    data1[strcspn(data1, "\n")] = 0;
    if (fgets(data2, sizeof(data2), stdin)) {
        data2[strcspn(data2, "\n")] = 0;
    } else {
        strcpy(data2, "");
    }
    char* result = solution(operation, data1, data2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time to XOR each character with corresponding key byte

✓ Linear Growth

Space Complexity

O(n)

Storage for the key and result, proportional to message length

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

One-Time Pad Cipher - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Cryptographically Secure Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler