# Legacy interface exports traditional RFC 1521 Base64 encodings

'encode', 'decode', 'encodebytes', 'decodebytes',

# Generalized interface for other encodings

'b64encode', 'b64decode', 'b32encode', 'b32decode',

'b16encode', 'b16decode',

# Base85 and Ascii85 encodings

'b85encode', 'b85decode', 'a85encode', 'a85decode',

# Standard Base64 encoding

'standard_b64encode', 'standard_b64decode',

# Some common Base64 alternatives. As referenced by RFC 3458, see thread

# starting at:

#

# http://zgp.org/pipermail/p2p-hackers/2001-September/000316.html

'urlsafe_b64encode', 'urlsafe_b64decode',

if isinstance(s, str):

try:

return s.encode('ascii')

except UnicodeEncodeError:

raise ValueError('string argument should contain only ASCII characters')

if isinstance(s, bytes_types):

return s

try:

return memoryview(s).tobytes()

except TypeError:

raise TypeError("argument should be a bytes-like object or ASCII "

"""Encode a byte string using Base64.

# Strip off the trailing newline

encoded = binascii.b2a_base64(s)[:-1]

if altchars is not None:

assert len(altchars) == 2, repr(altchars)

return encoded.translate(bytes.maketrans(b'+/', altchars))

"""Decode a Base64 encoded byte string.

s = _bytes_from_decode_data(s)

if altchars is not None:

altchars = _bytes_from_decode_data(altchars)

assert len(altchars) == 2, repr(altchars)

s = s.translate(bytes.maketrans(altchars, b'+/'))

if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s):

raise binascii.Error('Non-base64 digit found')

"""Encode a byte string using the standard Base64 alphabet.

"""Decode a byte string encoded with the standard Base64 alphabet.

"""Encode a byte string using a url-safe Base64 alphabet.

"""Decode a byte string encoded with the standard Base64 alphabet.

s = _bytes_from_decode_data(s)

s = s.translate(_urlsafe_decode_translation)

"""Encode a byte string using Base32.

if not isinstance(s, bytes_types):

s = memoryview(s).tobytes()

leftover = len(s) % 5

# Pad the last quantum with zero bits if necessary

if leftover:

s = s + bytes(5 - leftover) # Don't use += !

encoded = bytearray()

from_bytes = int.from_bytes

b32tab2 = _b32tab2

for i in range(0, len(s), 5):

c = from_bytes(s[i: i + 5], 'big')

encoded += (b32tab2[c >> 30] + # bits 1 - 10

b32tab2[(c >> 20) & 0x3ff] + # bits 11 - 20

b32tab2[(c >> 10) & 0x3ff] + # bits 21 - 30

b32tab2[c & 0x3ff] # bits 31 - 40

)

# Adjust for any leftover partial quanta

if leftover == 1:

encoded[-6:] = b'======'

elif leftover == 2:

encoded[-4:] = b'===='

elif leftover == 3:

encoded[-3:] = b'==='

elif leftover == 4:

encoded[-1:] = b'='

"""Decode a Base32 encoded byte string.

s = _bytes_from_decode_data(s)

if len(s) % 8:

raise binascii.Error('Incorrect padding')

# Handle section 2.4 zero and one mapping. The flag map01 will be either

# False, or the character to map the digit 1 (one) to. It should be

# either L (el) or I (eye).

if map01 is not None:

map01 = _bytes_from_decode_data(map01)

assert len(map01) == 1, repr(map01)

s = s.translate(bytes.maketrans(b'01', b'O' + map01))

if casefold:

s = s.upper()

# Strip off pad characters from the right. We need to count the pad

# characters because this will tell us how many null bytes to remove from

# the end of the decoded string.

l = len(s)

s = s.rstrip(b'=')

padchars = l - len(s)

# Now decode the full quanta

decoded = bytearray()

b32rev = _b32rev

for i in range(0, len(s), 8):

quanta = s[i: i + 8]

acc = 0

try:

for c in quanta:

acc = (acc << 5) + b32rev[c]

except KeyError:

raise binascii.Error('Non-base32 digit found') from None

decoded += acc.to_bytes(5, 'big')

# Process the last, partial quanta

if padchars:

acc <<= 5 * padchars

last = acc.to_bytes(5, 'big')

if padchars == 1:

decoded[-5:] = last[:-1]

elif padchars == 3:

decoded[-5:] = last[:-2]

elif padchars == 4:

decoded[-5:] = last[:-3]

elif padchars == 6:

decoded[-5:] = last[:-4]

else:

raise binascii.Error('Incorrect padding')

"""Encode a byte string using Base16.

"""Decode a Base16 encoded byte string.

s = _bytes_from_decode_data(s)

if casefold:

s = s.upper()

if re.search(b'[^0-9A-F]', s):

raise binascii.Error('Non-base16 digit found')

# Helper function for a85encode and b85encode

if not isinstance(b, bytes_types):

b = memoryview(b).tobytes()

padding = (-len(b)) % 4

if padding:

b = b + b'\0' * padding

words = struct.Struct('!%dI' % (len(b) // 4)).unpack(b)

a85chars2 = _a85chars2

a85chars = _a85chars

chunks = [b'z' if foldnuls and not word else

b'y' if foldspaces and word == 0x20202020 else

(chars2[word // 614125] +

chars2[word // 85 % 7225] +

chars[word % 85])

for word in words]

if padding and not pad:

if chunks[-1] == b'z':

chunks[-1] = chars[0] * 5

chunks[-1] = chunks[-1][:-padding]

"""Encode a byte string using Ascii85.

result = _85encode(b, _a85chars, _a85chars2, pad, True, foldspaces)

if adobe:

result = _A85START + result

if wrapcol:

wrapcol = max(2 if adobe else 1, wrapcol)

chunks = [result[i: i + wrapcol]

for i in range(0, len(result), wrapcol)]

if adobe:

if len(chunks[-1]) + 2 > wrapcol:

chunks.append(b'')

result = b'\n'.join(chunks)

if adobe:

result += _A85END

"""Decode an Ascii85 encoded byte string.

b = _bytes_from_decode_data(b)

if adobe:

if not (b.startswith(_A85START) and b.endswith(_A85END)):

raise ValueError("Ascii85 encoded byte sequences must be bracketed "

"by {!r} and {!r}".format(_A85START, _A85END))

b = b[2:-2] # Strip off start/end markers

#

# We have to go through this stepwise, so as to ignore spaces and handle

# special short sequences

#

packI = struct.Struct('!I').pack

decoded = []

decoded_append = decoded.append

curr = []

curr_append = curr.append

curr_clear = curr.clear

for x in b + b'u' * 4:

if b'!'[0] <= x <= b'u'[0]:

curr_append(x)

if len(curr) == 5:

acc = 0

for x in curr:

acc = 85 * acc + (x - 33)

try:

decoded_append(packI(acc))

except struct.error:

raise ValueError('Ascii85 overflow') from None

curr_clear()

elif x == b'z'[0]:

if curr:

raise ValueError('z inside Ascii85 5-tuple')

decoded_append(b'\0\0\0\0')

elif foldspaces and x == b'y'[0]:

if curr:

raise ValueError('y inside Ascii85 5-tuple')

decoded_append(b'\x20\x20\x20\x20')

elif x in ignorechars:

# Skip whitespace

continue

else:

raise ValueError('Non-Ascii85 digit found: %c' % x)

result = b''.join(decoded)

padding = 4 - len(curr)

if padding:

# Throw away the extra padding

result = result[:-padding]

"""Encode an ASCII-encoded byte array in base85 format.

"""Decode base85-encoded byte array"""

b = _bytes_from_decode_data(b)

global _b85dec

if _b85dec is None:

_b85dec = [None] * 256

for i, c in enumerate(_b85chars):

_b85dec[c[0]] = i

padding = (-len(b)) % 5

b = b + b'~' * padding

out = []

packI = struct.Struct('!I').pack

for i in range(0, len(b), 5):

chunk = b[i:i + 5]

acc = 0

try:

for c in chunk:

acc = acc * 85 + _b85dec[c]

except TypeError:

for j, c in enumerate(chunk):

if _b85dec[c] is None:

raise ValueError('bad base85 character at position %d'

% (i + j)) from None

raise

try:

out.append(packI(acc))

except struct.error:

raise ValueError('base85 overflow in hunk starting at byte %d'

% i) from None

result = b''.join(out)

if padding:

result = result[:-padding]

"""Encode a file; input and output are binary files."""

while True:

s = input.read(MAXBINSIZE)

if not s:

break

while len(s) < MAXBINSIZE:

ns = input.read(MAXBINSIZE-len(s))

if not ns:

break

s += ns

line = binascii.b2a_base64(s)

"""Decode a file; input and output are binary files."""

while True:

line = input.readline()

if not line:

break

s = binascii.a2b_base64(line)

try:

m = memoryview(s)

except TypeError as err:

msg = "expected bytes-like object, not %s" % s.__class__.__name__

raise TypeError(msg) from err

if m.format not in ('c', 'b', 'B'):

msg = ("expected single byte elements, not %r from %s" %

(m.format, s.__class__.__name__))

raise TypeError(msg)

if m.ndim != 1:

msg = ("expected 1-D data, not %d-D data from %s" %

(m.ndim, s.__class__.__name__))

"""Encode a bytestring into a bytestring containing multiple lines

_input_type_check(s)

pieces = []

for i in range(0, len(s), MAXBINSIZE):

chunk = s[i : i + MAXBINSIZE]

pieces.append(binascii.b2a_base64(chunk))

"""Legacy alias of encodebytes()."""

import warnings

warnings.warn("encodestring() is a deprecated alias, use encodebytes()",

DeprecationWarning, 2)

"""Legacy alias of decodebytes()."""

import warnings

warnings.warn("decodestring() is a deprecated alias, use decodebytes()",

DeprecationWarning, 2)

"""Small main program"""

import sys, getopt

try:

opts, args = getopt.getopt(sys.argv[1:], 'deut')

except getopt.error as msg:

sys.stdout = sys.stderr

print(msg)

print("""usage: %s [-d|-e|-u|-t] [file|-]

-t: encode and decode string 'Aladdin:open sesame'"""%sys.argv[0])

sys.exit(2)

func = encode

for o, a in opts:

if o == '-e': func = encode

if o == '-d': func = decode

if o == '-u': func = decode

if o == '-t': test(); return

if args and args[0] != '-':

with open(args[0], 'rb') as f:

func(f, sys.stdout.buffer)

else:

s0 = b"Aladdin:open sesame"

print(repr(s0))

s1 = encodebytes(s0)

print(repr(s1))

s2 = decodebytes(s1)

print(repr(s2))