Python-3.x - 将bytearray的字符串表示形式转换回字符串

Question

The back-story here is a little verbose, but basically I want to take a string like b'\\x04\\x0e\\x1d' and cast it back into a bytearray.

I am working on a basic implementation of a one time pad, where I take a plaintext A and shared key B to generate a ciphertext C accoring to the equation A⊕B=C . Then I reverse the process with the equation C⊕B=A .

I've already found plenty of python3 functions to encode strings as bytes and then xor the bytes, such as the following:

def xor_strings(xs, ys):
    return "".join(chr(ord(x) ^ ord(y)) for x, y in zip(xs, ys)).encode()

A call to xor_strings() then returns a bytearray:

print( xor_strings("foo", "bar"))

But when I print it to the screen, what I'm shown is actually a string. So I'm assuming that python is just calling some str() function on the bytearray, and I get something that looks like the following:

b'\\x04\\x0e\\x1d'

Herein lies the problem. I want to create a new bytearray from that string. Normally I would just call decode() on the bytearray. But if I enter `b'\\x04\\x0e\\x1d' as input, python sees it as a string, not a bytearray!

How can I take a string like b'\\x04\\x0e\\x1d' as user input and cast it back into a bytearray?

Answer 1

As discussed in the comments, use base64 to send binary data in text form.

import base64

def xor_strings(xs, ys):
    return "".join(chr(ord(x) ^ ord(y)) for x, y in zip(xs, ys)).encode()

# ciphertext is bytes
ciphertext = xor_strings("foo", "bar")
# >>> b'\x04\x0e\x1d'

# ciphertext_b64 is *still* bytes, but only "safe" ones (in the printable ASCII range)
ciphertext_b64 = base64.encodebytes(ciphertext)
# >>> b'BA4d\n'

Now we can transfer the bytes:

# ...we could interpret them as ASCII and print them somewhere
safe_string = ciphertext_b64.decode('ascii')
# >>> BA4d

# ...or write them to a file (or a network socket)
with open('/tmp/output', 'wb') as f:
    f.write(ciphertext_b64)

And the recipient can retrieve the original message by:

# ...reading bytes from a file (or a network socket)
with open('/tmp/output', 'rb') as f:
    ciphertext_b64_2 = f.read()

# ...or by reading bytes from a string
ciphertext_b64_2 = safe_string.encode('ascii')
# >>> b'BA4d\n'

# and finally decoding them into the original nessage
ciphertext_2 = base64.decodestring(ciphertext_b64_2)
# >>> b'\x04\x0e\x1d'

Of course when it comes to writing bytes to a file or to the network, encoding them as base64 first is superfluous. You can write/read the ciphertext directly if it's the only file content. Only if the ciphertext it is part of a higher structure (JSON, XML, a config file...) encoding it as base64 becomes necessary again.

A note on the use of the words "decode" and "encode".

• To encode a string means to turn it from its abstract meaning ("a list of characters") into a storable representation ("a list of bytes"). The exact result of this operation depends on the byte encoding that is being used. For example:

  • ASCII encoding maps one character to one byte (as a trade-off it can't map all characters that can exist in a Python string).
  • UTF-8 encoding maps one character to 1-5 bytes, depending on the character.

• To decode a byte array means turning it from "a list of bytes" back into "a list of characters" again. This of course requires prior knowledge of what the byte encoding originally was.

ciphertext_b64 above is a list of bytes and is represented as b'BA4d\\n' on the Python console.

Its string equivalent, safe_string , looks very similar 'BA4d\\n' when printed to the console due to the fact that base64 is a sub-set of ASCII.

The data types however are still fundamentally different. Don't let the console output deceive you.

Answer 2

Responding to that final question only.

>>> type(b'\x04\x0e\x1d')
<class 'bytes'>
>>> bytearray(b'\x04\x0e\x1d')
bytearray(b'\x04\x0e\x1d')
>>> type(bytearray(b'\x04\x0e\x1d'))
<class 'bytearray'>