def decode(inval, outval):
"""Decode a file; input and output are binary files."""
while True:
line = inval.readline()
if not line:
break
outval.write(binascii.a2b_base64(line))
def urlsafe_b64decode(payload):
"""Decode bytes-like object or ASCII string using the URL
and filesystem-safe alphabet
:param bytes payload: bytes-like object or ASCII string
"""
return a2b_base64(
STRING_TOOLS._bytes_from_decode_data(payload)).decode("utf-8")
def decode(input, output):
"""Decode a file; input and output are binary files."""
while True:
line = input.readline()
if not line:
break
s = binascii.a2b_base64(line)
output.write(s)
def b64decode(todecode: str) -> bytes:
"""Decode a Base64 encoded byte string.
todecode is the byte string to decode. Optional altchars must be a
string of length 2 which specifies the alternative alphabet used
instead of the '+' and '/' characters.
The decoded string is returned. A binascii.Error is raised if todecode is
incorrectly padded.
If validate is False (the default), non-base64-alphabet characters are
discarded prior to the padding check. If validate is True,
non-base64-alphabet characters in the input result in a binascii.Error.
"""
return binascii.a2b_base64(_bytes_from_decode_data(todecode))
def b64decode(todecode, altchars=None, validate=False):
"""Decode a Base64 encoded byte string.
todecode is the byte string to decode. Optional altchars must be a
string of length 2 which specifies the alternative alphabet used
instead of the '+' and '/' characters.
The decoded string is returned. A binascii.Error is raised if todecode is
incorrectly padded.
If validate is False (the default), non-base64-alphabet characters are
discarded prior to the padding check. If validate is True,
non-base64-alphabet characters in the input result in a binascii.Error.
"""
todecode = _bytes_from_decode_data(todecode)
if altchars is not None:
altchars = _bytes_from_decode_data(altchars)
assert len(altchars) == 2, repr(altchars)
todecode = todecode.translate(bytes.maketrans(altchars, b"+/"))
if validate and not re.match(b"^[A-Za-z0-9+/]*={0,2}$", todecode):
raise binascii.Error("Non-base64 digit found")
return binascii.a2b_base64(todecode)
def decodebytes(todecode):
"""Decode a bytestring of base-64 data into a bytestring."""
if not isinstance(todecode, BYTES_TYPES):
raise TypeError("expected bytes, not %s" % todecode.__class__.__name__)
return binascii.a2b_base64(todecode)
print("-- Binary<->Hex Conversions --")
# Binary data.
data = b"CircuitPython is Awesome!"
print("Original Binary Data: ", data)
# Get the hexadecimal representation of the binary data
hex_data = hexlify(data)
print("Hex Data: ", hex_data)
# Verify data
assert (
hex_data == b"43697263756974507974686f6e20697320417765736f6d6521",
), "hexlified data does not match expected data."
# Get the binary data represented by hex_data
bin_data = unhexlify(hex_data)
print("Binary Data: ", bin_data)
# Verify data
assert bin_data == data, "unhexlified binary data does not match original binary data."
print("-- Base64 ASCII <-> Binary Conversions --")
data = b"Blinka"
print("Original Binary Data: ", data)
# Convert binary data to a line of ASCII characters in base64 coding.
b64_ascii_data = b2a_base64(data)
print("Base64 ASCII Data: ", b64_ascii_data)
assert b64_ascii_data == b"Qmxpbmth\n", "Expected base64 coding does not match."
# Convert a block of base64 data back to binary data.
bin_data = a2b_base64(b"Qmxpbmth\n")
print("Converted b64 ASCII->Binary Data: ", bin_data)
assert bin_data == data, "Expected binary data does not match."
def load_pem(contents, pem_marker):
"""Loads a PEM file.
:param contents: the contents of the file to interpret
:param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
when your file has '-----BEGIN RSA PRIVATE KEY-----' and
'-----END RSA PRIVATE KEY-----' markers.
:return: the base64-decoded content between the start and end markers.
@raise ValueError: when the content is invalid, for example when the start
marker cannot be found.
"""
# We want bytes, not text. If it's text, it can be converted to ASCII bytes.
if not is_bytes(contents):
contents = contents.encode("ascii")
(pem_start, pem_end) = _markers(pem_marker)
pem_lines = []
in_pem_part = False
for line in contents.split(b"\n"):
line = line.strip()
# Skip empty lines
if not line:
continue
# Handle start marker
if line == pem_start:
if in_pem_part:
raise ValueError('Seen start marker "%s" twice' % pem_start)
in_pem_part = True
continue
# Skip stuff before first marker
if not in_pem_part:
continue
# Handle end marker
if in_pem_part and line == pem_end:
in_pem_part = False
break
# Load fields
if b":" in line:
continue
pem_lines.append(line)
# Do some sanity checks
if not pem_lines:
raise ValueError('No PEM start marker "%s" found' % pem_start)
if in_pem_part:
raise ValueError('No PEM end marker "%s" found' % pem_end)
# Base64-decode the contents
pem = b"".join(pem_lines)
return a2b_base64(pem)
def decodebytes(s):
"""Decode a bytestring of base-64 data into a bytestring."""
if not isinstance(s, bytes_types):
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
return binascii.a2b_base64(s)