base64深入探究

import base64, json

primeval: bytes = b'<>??><?<>['
outcome = base64.b64encode(primeval)
print('outcome:', outcome)

print('altchars(-_):', base64.b64encode(primeval, altchars=b'-_'))
print('urlsafe:', base64.urlsafe_b64encode(primeval))

encoded: bytes = b'PD4_Pz48Pzw-Ww=='

encoded = encoded.rstrip(b'=')

_, modulus = divmod(len(encoded), 4)
print(modulus)

encoded += b'=' * (4 - modulus)
print('encoded right padded:', encoded)
print(base64.b64decode(encoded, altchars='-_', validate=True))

v: str = 'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ'
_, remainder = divmod(len(v), 4)

if remainder:
    v += '=' * (4 - remainder)
    t = base64.b64decode(v, altchars='-_', validate=True)
    dic = json.loads(t)
    print(dic)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

import base64


def b64encode(s: bytes | bytearray, altchars=None):
    alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    ret = bytearray()
    length = len(s)
    alternate = 0

    for offset in range(0, length, 3):
        if offset + 3 <= length:
            triple = s[offset:offset + 3]
        else:
            triple = s[offset:]
            alternate = 3 - len(triple)
            triple += b'\x00' * alternate

        integer = int.from_bytes(triple, 'big')

        for i in range(18, -1, -6):
            if i == 18:
                index = integer >> i
            else:
                index = integer >> i & 0x3F
            ret.append(alphabet[index])

        for i in range(1, 1 + alternate):
            ret[-i] = ord('=')
    if altchars is not None:
        assert len(altchars) == 2, repr(altchars)
        ret = ret.translate(bytes.maketrans(b'+/', altchars), delete=b'')
    return bytes(ret)


s = b'<>??><?<>['
print(b64encode(s, altchars=b'-_'))
print(base64.b64encode(s))
print(base64.b64encode(s, altchars=b'-_'))
print(base64.urlsafe_b64encode(s))

 

import base64
import binascii
import re

bytes_types = (bytes, bytearray)


def _bytes(s):
    if isinstance(s, str):
        try:
            return s.encode('ascii')
        except UnicodeEncodeError:
            raise ValueError('string should contain only ASCII characters')
    elif isinstance(s, bytes_types):
        return s

    try:
        return memoryview(s).tobytes()
    except TypeError:
        raise TypeError


def b64decode(s, altchars=None, validate=False):
    alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

    b = bytearray()
    s = _bytes(s)
    equalities = 0
    if altchars is not None:
        altchars = _bytes(altchars)
        assert len(altchars) == 2, repr(altchars)
        s = s.translate(bytes.maketrans(altchars, b'+/'))
    if validate and not re.fullmatch(b'[A-Za-z0-9+/]*={0,2}', s):
        raise binascii.Error('Non-base64 digit found')

    for offset in range(0, len(s), 4):
        v = 0x00
        block = s[offset:4 + offset]

        for i, c in enumerate(reversed(block)):
            index = alphabet.find(c)
            if index == -1:
                equalities += 1
                continue
            v += index << i * 6
        b.extend(v.to_bytes(3, 'big', signed=False))
    if equalities == 0:
        return bytes(b)
    else:
        return bytes(b[:-equalities])


print(b64decode('ab=='))
print(base64.b64decode('ab=='))
print(b64decode('AAAA'))
print(base64.b64decode('AAAA'))
print(b64decode('AAA='))
print(base64.b64decode('AAA='))