How do I encode hexadecimal to base64 in python?

Question

If I try to do:

from base64 import b64encode
b64encode('ffffff')

I get this error:

Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    base64.b64encode('ffffff')
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/base64.py", line 58, in b64encode
    encoded = binascii.b2a_base64(s, newline=False)
TypeError: a bytes-like object is required, not 'str'

Because it said bytes-like object I then tried this:

b64encode(bytes('ffffff'))

Which failed.

Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    b64encode(bytes('ffffff'))
TypeError: string argument without an encoding

Finally, using the .encode('utf-8') function:

b64encode('ffffff'.encode('utf-8'))

With incorrect output b'ZmZmZmZm', the correct base64 encoding is ////.

I already know how to decode b64 to hex so don't say how to do that.

Edit: This question got flagged for being the same as converting hex strings to hex bytes. This involves base64.

`bytes('fffff', 'UTF-8')` is what you're looking for. But I don't think `'ffffff'` does what you think it does, it's not the same as `'\xff\xff\xff'`. — Torxed, Feb 24 '19 at 18:53
It didn't work, just returned `b'ZmZmZmZm'` again. (Assuming you meant: `b64encode(bytes('ffffff', 'utf-8'))`) — Eric Jin, Feb 24 '19 at 19:00
Possible duplicate of [Python: How to convert a string containing hex bytes to a hex string](https://stackoverflow.com/questions/10824319/python-how-to-convert-a-string-containing-hex-bytes-to-a-hex-string) — snakecharmerb, Feb 24 '19 at 19:04

score 3 · Accepted Answer · edited Feb 24 '19 at 19:21

3

To fully go from the string ffffff to base64 of the hex value, you need to run it through some encoding and decoding, using the codecs module:

import codecs
# Convert string to hex
hex = codecs.decode('ffffff', 'hex')
# Encode as base64 (bytes)
codecs.encode(hex, 'base64')

For an odd-length string like 0xfffff you need to put a zero at the beginning of the hex string (0x0fffff), otherwise python will give you an error.

edited Feb 24 '19 at 19:21

Eric Jin

3,836
4
19
45

answered Feb 24 '19 at 18:57

match

10,388
3
23
41

2

You can also go through `struct.pack('B', int('ff',16))` – Torxed Feb 24 '19 at 18:59
Yes - though if you're pulling in `codecs` for base64, it seems 'neater' to me to use it for both parts. – match Feb 24 '19 at 19:00
1

Absolutely agree, there's nothing fancy about going manual to solve this. But hopefully it teaches someone why and how codecs work. So I threw in a small explanation of how hex works. – Torxed Feb 24 '19 at 19:10
@EricJin, you could append using modolus to get the correct length. `s = s + '0'*(len(s)%2)`. Which would only append `0` if the length of the string is not equal to a round number. However, this will give you inaccurate results since you probably don't know if you need to append the `0` at the start or end of your string? My solution works on odd lengths as well. However it simply ignores the odd number that isn't complete. So beware of that. – Torxed Feb 24 '19 at 19:12
Using `codecs.encode` always seems to stick a newline character at the end of the result for me, but `base64.b64encode` does not. H/T [this question](https://stackoverflow.com/q/40454177/2829764) – kuzzooroo Jan 11 '23 at 05:22

Torxed · Answer 2 · 2019-02-24T19:18:17.137

Here's an alternative to using codecs.
This one is a bit less readable, but works great and hopefully teaches you how codecs, hex and integers work. (word of caution, works on odd lengths, but will ignore the odd byte-string-representation)

import struct
s = 'ffffff'
b''.join([struct.pack('B', int(''.join(x), 16)) for x in zip(s[0::2], s[1::2])])

Which should give you b'\xff\xff\xff'.

Your main problem is probably that you think 'ffffff' represents the values 255, 255, 255. Which they don't. They're still in a string format with the letters ff. Subsequently you need to parse/convert the string representation of hex, into actual hex. We can do this by first passing the string through int() which can intemperate hex in string representation format.

You will need to convert each pair of ff individually by doing int('ff', 16) which tells Python to intemperate the string as a base-16 integer (hex-numbers).

And then convert that integer into a bytes like object representing that integer. That's where struct.pack comes in. It's meant for exactly this.

struct.pack('B', 255) # 255 is given to us by int('ff', 16)

Essentially, 'B' tells Python to pack the value 255 into a 1-byte-object, in this case, that gives us b'\xff' which is your end goal. Now, do this for every 2-pair of letters in your original data.

This is more of a manual approach where you'll iterate over 2 characters in the string at a time, and use the above description to bundle them into what you expect them to be. Or just use codecs, either way works.

Expanded version of the above oneliner:

import struct
hex_string = 'ffffff'
result = b''
for pair in zip(hex_string[0::2], hex_string[1::2]):
    value = int(''.join(pair), 16)
    result += struct.pack('B', value)

At the very least, I hope this explains how hex works on a practical level. And how the computer interpenetrates hour humanly readable version of bits and bytes.

How do I encode hexadecimal to base64 in python?

2 Answers2