Cipher program losing accuracy

Question

I have a program in python that takes two strings. One is the plain text string, another is the cipher key. what it does is go over each of the characters and xors the bits with the cipher characters. But when going back and forth a few of the letter do not seem to change properly. Here is the code:

//turns int into bin string length 8
def bitString(n):
    bin_string = bin(n)[2:]
    bin_string = ("0" * (8 - len(bin_string))) + bin_string
    return bin_string

//xors the bits
def bitXOR(b0, b1):
    nb = ""
    for x in range(min(len(b0), len(b1))):
        nb += "0" if b0[x] == b1[x] else "1"
    return nb

//takes 2 chars, turns them into bin strings, xors them, then returns the new char
def cypherChar(c0, c1):
    return chr(int(bitXOR(bitString(ord(c0)), bitString(ord(c1))), 2))

//takes s0 (the plaintext) and encrypts it using the cipher key (s1)
def cypherString(s0, s1):
    ns = ""
    for x in range(len(s0)):
        ns += cypherChar(s0[x], s1[x%len(s1)])
    return ns

For example sometimes in a long string the word 'test' will cipher back into 'eest', and stuff like that

I have checked over the code a dozen times and I can't figure out whats causing some of the characters to change. Is it possible some characters just behave strangely?

EDIT:

example:

This is a test

Due to the fact that in the last test

Some symbols: !@#$%^&*()

were not changed properly

I am retesting

END

using the cipher key : 'cypher key'

translates back to :

This is a test

Due to toe aact that in the last sest

Some symbols: !@#$%^&*()

were not changed properly

I am retestiig

END

Answer 1

Sorry it its a little messy, I put it together real quick

from binascii import hexlify, unhexlify
from sys import version_info

def bit_string(string):
    if version_info >= (3, 0):
        return bin(int.from_bytes(string.encode(), 'big'))
    else:
        return bin(int(hexlify(string), 16))

def bitXOR_encrypt(plain_text, key):
    encrypted_list = []
    for j in range(2, len(plain_text)):
        encrypted_list.append(int(plain_text[j]) ^ int(key[j])) #Assume the key and string are the same length
    return encrypted_list

def decrypt(cipher_text, key):
    decrypted_list = []
    for j in range(2, len(cipher_text)): #or xrange
        decrypted_list.append(int(cipher_text[j]) ^ int(key[j])) #Again assumes key is the same length as the string

    decrypted_list = [str(i) for i in decrypted_list]
    add_binary = "0b" + "".join(decrypted_list)
    decrypted_string = int(add_binary, 2)
    if version_info >= (3, 0):
        message =  decrypted_string.to_bytes((decrypted_string.bit_length() + 7) // 8, 'big').decode()
    else:
        message = unhexlify('%x' % decrypted_string)
    return message


def main():
    plain_text = "Hello"
    plain_text_to_bits = bit_string(plain_text)
    key_to_bits = bit_string("candy")

    #Encrypt
    cipher_text = bitXOR_encrypt(plain_text_to_bits, key_to_bits)

    #make Strings
    cipher_text_string = "".join([str(i) for i in cipher_text])
    key_string = "".join([str(i) for i in key_to_bits])

    #Decrypt
    decrypted_string = decrypt("0B"+cipher_text_string, key_string)

    print("plain text: %s" % plain_text)
    print("plain text to bits: % s" % plain_text_to_bits)
    print("key string in bits: %s" % key_string)
    print("Ciphered Message: %s" %cipher_text_string)
    print("Decrypted String: %s" % decrypted_string)

main()

for more details or example code you can visit my repository either on github https://github.com/marcsantiago/one_time_pad_encryption

Also, I know that in this example the key is the same length as the string. If you want to use a string that is smaller than the string try wrapping it like in a vigenere cipher (http://en.wikipedia.org/wiki/Vigenère_cipher)

Answer 2

I think you are overcomplicating things:

def charxor(s1, s2):
    return chr(ord(s1) ^ ord(s2))

def wordxor(w1, w2):
    return ''.join(charxor(w1[i], w2[i]) for i in range(min(len(w1), len(w2))))

word = 'test'
key = 'what'
cyphered = wordxor(word, key)
uncyphered = wordxor(cyphered, key)

print(repr(cyphered))
print(uncyphered)

You get

'\x03\r\x12\x00'
test

There is a fairly good explanation of Python's bit arithmetic in How do you get the logical xor of two variables in Python?

Answer 3

I could find nothing wrong with the results of your functions when testing with your input data and key. To demonstrate, you could try this test code which should not fail:

import random

def random_string(n):
    return ''.join(chr(random.getrandbits(8)) for _ in range(n))

for i in range(1000):
    plaintext = random_string(500)
    key = random_string(random.randrange(1,100))
    ciphertext = cypherString(plaintext, key)
    assert cypherString(ciphertext, key) == plaintext

If you can provide a definitive sample of plain text, key, and cipher text that fails, I can look further.