XOR Cipher Encoder & Decoder

Mathematical Properties of XOR

The XOR operation (often denoted as ⊕) has several mathematical properties that make it useful for cryptography:

• Commutative: A ⊕ B = B ⊕ A
• Associative: A ⊕ (B ⊕ C) = (A ⊕ B) ⊕ C
• Identity element: A ⊕ 0 = A
• Self-inverse: A ⊕ A = 0
• Cancellation: A ⊕ B ⊕ B = A

The last property is particularly important for cryptography: if we XOR a plaintext with a key to get a ciphertext, we can recover the plaintext by XORing the ciphertext with the same key.

Historical and Practical Applications

One-Time Pad

The most secure implementation of XOR encryption is the One-Time Pad (OTP), which uses:

1. A truly random key
2. A key as long as the message
3. Each key used only once

When implemented correctly, OTP provides perfect secrecy and is mathematically unbreakable. However, the key management requirements make it impractical for most applications.

Stream Ciphers

Many modern stream ciphers use XOR as their final operation. They generate a pseudorandom keystream that is XORed with the plaintext. Examples include:

• RC4 (although now considered insecure)
• ChaCha20
• A5/1 and A5/2 (used in GSM)

Other Applications

• Error Detection: XOR is used in checksums and CRC (Cyclic Redundancy Check)
• Random Number Generation: XOR is used in some pseudorandom number generators
• Block Cipher Modes: Many block cipher modes (like CTR mode) effectively turn a block cipher into a stream cipher using XOR

Security Considerations

Weaknesses of Basic XOR Cipher

While XOR is a fundamental operation in cryptography, using it in a simple way (like the basic XOR cipher) has several vulnerabilities:

• Key Reuse: Reusing the same key for multiple messages is extremely insecure. If two ciphertexts C₁ and C₂ are created using the same key K, then C₁ ⊕ C₂ = P₁ ⊕ P₂ (where P₁ and P₂ are the plaintexts). This eliminates the key entirely and allows statistical attacks.
• Short, Repeating Keys: If a short key is repeated, patterns in the ciphertext can reveal information about the plaintext and key.
• Known Plaintext Attacks: If an attacker knows parts of the plaintext and corresponding ciphertext, they can recover portions of the key.
• Predictable Keys: Using predictable keys dramatically reduces security.

function xorEncrypt(input, key, inputType = 'text', keyType = 'text', outputType = 'text') {
    // Convert input to byte array based on input type
    let inputBytes = [];
    if (inputType === 'text') {
        for (let i = 0; i < input.length; i++) {
            inputBytes.push(input.charCodeAt(i));
        }
    } else if (inputType === 'hex') {
        for (let i = 0; i < input.length; i += 2) {
            const hex = input.substr(i, 2);
            inputBytes.push(parseInt(hex, 16));
        }
    } else if (inputType === 'binary') {
        input = input.replace(/\s/g, '');
        for (let i = 0; i < input.length; i += 8) {
            const byte = input.substr(i, 8);
            inputBytes.push(parseInt(byte, 2));
        }
    }

    // Convert key to byte array based on key type
    let keyBytes = [];
    if (keyType === 'text') {
        for (let i = 0; i < key.length; i++) {
            keyBytes.push(key.charCodeAt(i));
        }
    } else if (keyType === 'hex') {
        for (let i = 0; i < key.length; i += 2) {
            const hex = key.substr(i, 2);
            keyBytes.push(parseInt(hex, 16));
        }
    } else if (keyType === 'binary') {
        key = key.replace(/\s/g, '');
        for (let i = 0; i < key.length; i += 8) {
            const byte = key.substr(i, 8);
            keyBytes.push(parseInt(byte, 2));
        }
    } else if (keyType === 'decimal') {
        keyBytes = [parseInt(key)];
    }

    // Apply XOR operation
    let resultBytes = [];
    for (let i = 0; i < inputBytes.length; i++) {
        const keyByte = keyBytes[i % keyBytes.length];
        resultBytes.push(inputBytes[i] ^ keyByte);
    }

    // Convert result to desired output format
    if (outputType === 'text') {
        return resultBytes.map(byte => String.fromCharCode(byte)).join('');
    } else if (outputType === 'hex') {
        return resultBytes.map(byte => byte.toString(16).padStart(2, '0')).join('');
    } else if (outputType === 'binary') {
        return resultBytes.map(byte => byte.toString(2).padStart(8, '0')).join(' ');
    }

    return '';
}

def xor_encrypt(input_data, key, input_type='text', key_type='text', output_type='text'):
    # Convert input to byte array based on input type
    input_bytes = []
    if input_type == 'text':
        input_bytes = [ord(c) for c in input_data]
    elif input_type == 'hex':
        input_bytes = [int(input_data[i:i+2], 16) for i in range(0, len(input_data), 2)]
    elif input_type == 'binary':
        input_data = input_data.replace(' ', '')
        input_bytes = [int(input_data[i:i+8], 2) for i in range(0, len(input_data), 8)]

    # Convert key to byte array based on key type
    key_bytes = []
    if key_type == 'text':
        key_bytes = [ord(c) for c in key]
    elif key_type == 'hex':
        key_bytes = [int(key[i:i+2], 16) for i in range(0, len(key), 2)]
    elif key_type == 'binary':
        key = key.replace(' ', '')
        key_bytes = [int(key[i:i+8], 2) for i in range(0, len(key), 8)]
    elif key_type == 'decimal':
        key_bytes = [int(key)]

    # Apply XOR operation
    result_bytes = []
    for i in range(len(input_bytes)):
        key_byte = key_bytes[i % len(key_bytes)]
        result_bytes.append(input_bytes[i] ^ key_byte)

    # Convert result to desired output format
    if output_type == 'text':
        return ''.join(chr(b) for b in result_bytes)
    elif output_type == 'hex':
        return ''.join(f'{b:02x}' for b in result_bytes)
    elif output_type == 'binary':
        return ' '.join(f'{b:08b}' for b in result_bytes)

    return ''

Advanced Concepts in XOR-based Cryptography

Key Expansion

Rather than simply repeating a short key, modern ciphers use key expansion algorithms to generate a larger, more unpredictable keystream from an initial key. This significantly improves security.

Combining with Other Operations

XOR is often combined with other operations like substitution, permutation, and modular addition to create robust cryptographic algorithms. For example, many block ciphers use a combination of these operations in their round functions.

Diffusion and Confusion

Shannon's principles of diffusion (spreading the influence of plaintext bits across the ciphertext) and confusion (making the relationship between key and ciphertext complex) are often implemented using XOR along with other operations.

Conclusion

The XOR cipher represents one of the fundamental building blocks of modern cryptography. Its mathematical properties make it invaluable in cryptographic algorithms, yet using it alone with simple key management is insecure. Understanding XOR is essential for grasping how more complex cryptographic systems work, as nearly all modern encryption algorithms incorporate XOR operations in some way. While the basic XOR cipher is not suitable for serious security applications, the operation itself remains at the heart of secure cryptographic systems when properly implemented with strong key management and additional cryptographic techniques.