Python base64.b64decode() Examples

def get_tray_icon(self):
        base64_data = '''iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABHN
                         CSVQICAgIfAhkiAAAAQNJREFUOI3t1M9KAlEcxfHPmP0xU6Ogo
                         G0teoCiHjAIfIOIepvKRUE9R0G0KNApfy0c8hqKKUMrD9zVGc4
                         9nPtlsgp5n6qSVSk7cBG8CJ6sEX63UEcXz4jE20YNPbygPy25Q
                         o6oE+fEPXFF7A5yA9Eg2sQDcU3sJd6k89O4iiMcYKVol3rH2Mc
                         a1meZ4hMdNPCIj+SjHHfFZU94/0Nwlv4rWoY7vhrdeLNoO86bG
                         lym/ge3lsHDdI2fojbBG6sUtzOiQ1wQOwk6GwWKHeJyHtxOcFi
                         0TpFaxmnhNcyIW45bQ6RS3Hq4MeB7Ltyahki9Gd2xidWiwG9va
                         nCZqi7xlZGVHfwN6+5nU/ccBUYAAAAASUVORK5CYII='''

        pm = Qg.QPixmap()
        pm.loadFromData(base64.b64decode(base64_data))
        i = Qg.QIcon()
        i.addPixmap(pm)
        return i

    # OFF BY DEFAULT
    # 0.2 SEC DELAY TO LET USER FINISH TYPING BEFORE INPUT BECOMES A DB QUERY 

def __init__(self, blob):
        super(Blob, self).__init__(blob)
        self._api = blob.get('url', '')

        #: Raw content of the blob.
        self.content = blob.get('content').encode()

        #: Encoding of the raw content.
        self.encoding = blob.get('encoding')

        #: Decoded content of the blob.
        self.decoded = self.content
        if self.encoding == 'base64':
            self.decoded = b64decode(self.content)

        #: Size of the blob in bytes
        self.size = blob.get('size')
        #: SHA1 of the blob
        self.sha = blob.get('sha') 

def get_username_password(userpass):
    """
    Please note: username and password can either be presented in plain text
    such as "admin:password" or base64 encoded such as "YWRtaW46cGFzc3dvcmQ=".
    Both forms should be returned from this function.
    """
    plaintext = base64.b64decode(userpass)

    segments = plaintext.split(':')
    count = len(segments)
    if count == 1:
        return segments[0], ''
    elif count == 2:
        return segments
    else:
        raise Exception('There should be at most two segments!') 

def lan_event(self):
        '''变更语言的方法'''
        #读取本地配置文件
        num = 0
        with open(".\data.ini",'rb') as f:
            self.lan_data = f.readlines()
        with open(".\data.ini",'wb') as f:
            for line in self.lan_data:
                if num == self.dual_host_view.currentRow() + 1:
                    data = base64.b64decode(line)
                    data = json.loads(data.decode())
                    data['lan'] = self.lan_input.currentIndex()
                    f.write(base64.b64encode(json.dumps(data).encode()))
                    f.write('\n'.encode())
                else:
                    f.write(line)
                num += 1

        a = QMessageBox()
        #写入成功提示
        a.information(a,self.tr("Success"),self.tr("Language will be changed after resrart the application")) 

def deserialize_ndarray(d):
    """
    Deserializes a JSONified :obj:`numpy.ndarray`. Can handle arrays serialized
    using any of the methods in this module: :obj:`"npy"`, :obj:`"b64"`,
    :obj:`"readable"`.

    Args:
        d (`dict`): A dictionary representation of an :obj:`ndarray` object.

    Returns:
        An :obj:`ndarray` object.
    """
    if 'data' in d:
        x = np.fromstring(
            base64.b64decode(d['data']),
            dtype=d['dtype'])
        x.shape = d['shape']
        return x
    elif 'value' in d:
        return np.array(d['value'], dtype=d['dtype'])
    elif 'npy' in d:
        return deserialize_ndarray_npy(d)
    else:
        raise ValueError('Malformed np.ndarray encoding.') 

def getColoredPathway(self, pathwayId, filetype="svg", revision=0,
            color=None, graphId=None):
        """Get a colored image version of the pathway.

        :param str pwId: The pathway identifier.
        :param int revision: The revision number of the pathway (use '0' for most recent version).
        :param str fileType:  The image type (One of 'svg', 'pdf' or 'png'). Not
            yet implemented. svg is returned for now.
        :returns: Binary form of the image.

        .. todo:: graphId, color parameters
        """

        url = self.url + "getColoredPathway?pwId={}".format(pathwayId)
        if revision:
            url += "&revision={}".format(revision)
        url += "&format=json"
        request = self.http_get(url)
        try:
            data = request['data']  
            return base64.b64decode(data)
        except:
            return request 

def image(self, Id):
        """ Return string containing PNG binary image data of 2D structure image

        ::

            >>> from bioservices import *
            >>> s = ChemSpider()
            >>> ret = s.image(1020)
            >>> with open("test.png", "w") as f:
            ...     f.write(ret)
            >>> s.on_web("test.png")
        """
        url = "Search.asmx/GetCompoundThumbnail?id=%s&token=%s" % (Id, self._token)
        res = self.http_get(url, frmt="xml")
        res = self.easyXML(res)
        #TODO python3 compatible !
        import base64
        image = base64.b64decode(res.root.text)
        return image 

def decrypt_ecb(cipher_text, key):
    """
    SM4(ECB)解密
    :param cipher_text: 密文
    :param key: 密钥, 小于等于16字节
    """
    cipher_text = b64decode(cipher_text)
    cipher_hex = _hex(cipher_text)

    # 密码检验
    key = _key_iv_check(key_iv=key)
    plain_hex_list = []
    for i in _range(len(cipher_text) // BLOCK_BYTE):
        sub_hex = cipher_hex[i * BLOCK_HEX:(i + 1) * BLOCK_HEX]
        plain = decrypt(cipher_num=int(sub_hex, 16),
                        mk=int(_hex(key), 16))
        plain_hex_list.append(num2hex(num=plain, width=BLOCK_HEX))

    plain_text = _padding(_unhex(''.join(plain_hex_list)),
                          mode=SM4_DECRYPT)
    return plain_text if PY2 else plain_text.decode(E_FMT)


# 密码块链接(CBC) 

def retrieve_zip(self, async_process_id):
        """ Retrieves ZIP file """
        result = self._retrieve_retrieve_result(async_process_id, 'true')
        state = result.find('mt:status', self._XML_NAMESPACES).text
        error_message = result.find('mt:errorMessage', self._XML_NAMESPACES)
        if error_message is not None:
            error_message = error_message.text

        # Check if there are any messages
        messages = []
        message_list = result.findall('mt:details/mt:messages', self._XML_NAMESPACES)
        for message in message_list:
            messages.append({
                'file': message.find('mt:fileName', self._XML_NAMESPACES).text,
                'message': message.find('mt:problem', self._XML_NAMESPACES).text
            })

        # Retrieve base64 encoded ZIP file
        zipfile_base64 = result.find('mt:zipFile', self._XML_NAMESPACES).text
        zipfile = b64decode(zipfile_base64)

        return state, error_message, messages, zipfile 

def decode(self, data64):
        data = b64decode(data64)
        inp = self.SECItem(0, data, len(data))
        out = self.SECItem(0, None, 0)

        e = self._PK11SDR_Decrypt(inp, out, None)
        LOG.debug("Decryption of data returned %s", e)
        try:
            if e == -1:
                LOG.error("Password decryption failed. Passwords protected by a Master Password!")
                self.handle_error()
                raise Exit(Exit.NEED_MASTER_PASSWORD)

            res = ct.string_at(out.data, out.len).decode(LIB_ENCODING)
        finally:
            # Avoid leaking SECItem
            self._SECITEM_ZfreeItem(out, 0)

        return res 

def load(data, encoding="utf8"):
    """ Loads a base64 encoded schematic `str` object, 
    or a non-base65 encoded `bytes` object; returns a 
    Schematics object containing a Schematic, and it's 
    metadata, like width, height and tags."""
    if isinstance(data, str):
        base64header = "bXNjaAB"
        if not data.startswith(base64header):
            raise ValueError(f"String should start with: {base64header}")
        data = bytes(data, encoding)
        data = b64decode(data)

    if isinstance(data, bytes):
        data = msch.parse(data)
        return data
    else:
        raise ValueError(f"Unknown or unsupported type: {type(data)}")

########################################
## Writer
######################################## 

def __init__(self, key):
        # self.key = base64.b64decode(key+"=")
        self.key = key
        # 设置加解密模式为AES的CBC模式
        self.mode = AES.MODE_CBC 

def voice():
    """1 sec ogg file without speech in base64"""
    ogg_b64 = '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'
    return base64.b64decode(ogg_b64) 

def decode_file_data(data):
    # Py3 raises binascii.Error instead of TypeError as in Py27
    try:
        return base64.b64decode(data)
    except (TypeError, binascii.Error):
        raise exception.Base64Exception() 

def fromKey(self, key, avroType):
        bytes = io.BytesIO(base64.b64decode(key))
        reader = DatumReader(avroType.schema)
        return reader.read(BinaryDecoder(bytes)) 

def decode_b(encoded):
    defects = []
    pad_err = len(encoded) % 4
    if pad_err:
        defects.append(errors.InvalidBase64PaddingDefect())
        padded_encoded = encoded + b'==='[:4-pad_err]
    else:
        padded_encoded = encoded
    try:
        # The validate kwarg to b64decode is not supported in Py2.x
        if not re.match(b'^[A-Za-z0-9+/]*={0,2}$', padded_encoded):
            raise binascii.Error('Non-base64 digit found')
        return base64.b64decode(padded_encoded), defects
    except binascii.Error:
        # Since we had correct padding, this must an invalid char error.
        defects = [errors.InvalidBase64CharactersDefect()]
        # The non-alphabet characters are ignored as far as padding
        # goes, but we don't know how many there are.  So we'll just
        # try various padding lengths until something works.
        for i in 0, 1, 2, 3:
            try:
                return base64.b64decode(encoded+b'='*i), defects
            except (binascii.Error, TypeError):    # Py2 raises a TypeError
                if i==0:
                    defects.append(errors.InvalidBase64PaddingDefect())
        else:
            # This should never happen.
            raise AssertionError("unexpected binascii.Error") 

def decoded_content(self):
        assert self.encoding == "base64", "unsupported encoding: %s" % self.encoding
        if atLeastPython3:
            content = bytearray(self.content, "utf-8")  # pragma no cover (covered by tests with Python 3.2)
        else:
            content = self.content
        return base64.b64decode(content) 

def cmd_decode(self, event, *args):
        """Decode from base64. 'b64 decode <base64>'"""
        # use the body directly so quotes are parsed correctly.
        return base64.b64decode(event["content"]["body"][12:]) 

def get_authorization():
    authorization = ecr.get_authorization_token()["authorizationData"][0]
    encoded_token = authorization["authorizationToken"]
    token = base64.b64decode(encoded_token).decode("utf-8")
    proxy = authorization["proxyEndpoint"]
    index = token.find(":")
    username = token[:index]
    password = token[index + 1 :]
    return {"username": username, "password": password, "endpoint": proxy} 

def _readBase64(data, dot):
    if isinstance(data, basestring):
        return base64.b64decode(data)
    else:
        raise PFASyntaxException("expected base64 data, not " + _trunc(repr(data)), dot) 

def __init__(self, sToken, sEncodingAESKey, sAppId):
        try:
            self.key = base64.b64decode(sEncodingAESKey + "=")
            assert len(self.key) == 32
        except Exception:
            throw_exception("[error]: EncodingAESKey unvalid !", FormatException)
            # return ierror.WXBizMsgCrypt_IllegalAesKey)
        self.token = sToken.encode()
        self.appid = sAppId.encode() 

def decrypt(self, text, appid):
        """对解密后的明文进行补位删除
        @param text: 密文
        @return: 删除填充补位后的明文
        """
        try:
            cryptor = AES.new(self.key, self.mode, self.key[:16])
            # 使用BASE64对密文进行解码，然后AES-CBC解密
            plain_text = cryptor.decrypt(base64.b64decode(text))
        except Exception as e:
            print(e)
            return ierror.WXBizMsgCrypt_DecryptAES_Error, None
        try:
            # pad = ord(plain_text[-1])
            pad = plain_text[-1]
            # 去掉补位字符串
            # pkcs7 = PKCS7Encoder()
            # plain_text = pkcs7.encode(plain_text)
            # 去除16位随机字符串
            content = plain_text[16:-pad]
            xml_len = socket.ntohl(struct.unpack("I", content[: 4])[0])
            xml_content = content[4: xml_len + 4]
            from_appid = content[xml_len + 4:]
        except Exception as e:
            return ierror.WXBizMsgCrypt_IllegalBuffer, None
        if from_appid != appid:
            return ierror.WXBizMsgCrypt_ValidateAppid_Error, None
        return 0, xml_content.decode() 

def test_create_base64_bundle(bundle_dir):
    with TemporaryDirectory() as scratch:
        directory_name = "directory-abcd"
        # make a subdirectory with a known name so that the bundle is always the same
        inpath = os.path.join(scratch, directory_name)
        os.mkdir(inpath)

        copy_tree(bundle_dir, inpath)
        out = PushCmd()._create_base64_bundle(inpath, "repo")

        outpath = os.path.join(scratch, "out")
        os.mkdir(outpath)

        # write the output tar
        tardata = base64.b64decode(out)
        tarfile_name = os.path.join(outpath, "bundle.tar.gz")
        with open(tarfile_name, "wb") as bundle:
            bundle.write(tardata)

        # uncompress the bundle
        with tarfile.open(tarfile_name) as bundle:
            bundle.extractall(path=outpath)

        outfiles = os.listdir(outpath)

        # ensure the surrouding directory was packed into the tar archive
        assert directory_name in outfiles 

def decrypted(pw_enc):
    """return decrypted password"""

    return base64.b64decode(pw_enc).decode("utf-8", "ignore") 

def to_python(self, value: str) -> bytes:
        return b64decode(value) 

def main():
    config = ConfigParser()
    config.read("./smtpd.cfg")


    store = storage.StorageControl(config)

    cnx = mysql.connector.connect(
            user="root", password="root",
            host="localhost",
            database="sarlacc")

    mysql_cursor = cnx.cursor()

    mysql_cursor.execute("SELECT dateSent, fromAddress, toAddressList, subject, body FROM mailitem;")

    for (dateSent, fromAddress, toAddressList, subject, body) in mysql_cursor:
        # tidy up fromAddress
        fromAddress = cleanupAddress(re.findall(r"<(.*?)>", fromAddress)[0])

        # tidy up toaAdressList
        toAddressList = re.findall(r"<(.*?)>", toAddressList)

        body = str(b64decode(body))

        store.store_email(subject, toAddressList, fromAddress, body, dateSent, [])

    mysql_cursor.close()
    cnx.close() 

def get_item_resource_data(item, context):
    global _kms_client
    resource_data = item.get(TASK_TR_RESOURCES, "{}")
    if item.get(TASK_TR_ENCRYPTED_RESOURCES):
        if _kms_client is None:
            _kms_client = boto_retry.get_client_with_retries("kms", ["decrypt"], context=context)
        resource_data = _kms_client.decrypt(CiphertextBlob=base64.b64decode(resource_data))["Plaintext"]
    return resource_data if type(resource_data) in [dict, list] else json.loads(resource_data) 

def decrypt_cbc(cipher_text, key, iv):
    """
    SM4(CBC)解密
    :param cipher_text: 密文
    :param key: 密钥 小于等于16字节
    :param iv: 初始化向量 小于等于16字节
    """
    cipher_text = b64decode(cipher_text)
    cipher_hex = _hex(cipher_text)

    # 密钥检测
    key = _key_iv_check(key_iv=key)
    # 初始化向量检测
    iv = _key_iv_check(key_iv=iv)
    ivs = [int(_hex(iv), 16)]
    plain_hex_list = []
    for i in _range(len(cipher_text) // BLOCK_BYTE):
        sub_hex = cipher_hex[i * BLOCK_HEX:(i + 1) * BLOCK_HEX]
        cipher = int(sub_hex, 16)
        plain = (ivs[i] ^ decrypt(cipher_num=cipher,
                                  mk=int(_hex(key), 16)))
        ivs.append(cipher)
        plain_hex_list.append(num2hex(num=plain, width=BLOCK_HEX))

    plain_text = _padding(_unhex(''.join(plain_hex_list)),
                          mode=SM4_DECRYPT)
    return plain_text if PY2 else plain_text.decode(E_FMT) 

def load_pem_data(filename, specifier):
	"""Loads the PEM payload, designated with a BEGIN and END specifier, from a
	file given by its filename."""
	data = None
	with open(filename, "r") as f:
		spec_begin = "-----BEGIN " + specifier + "-----"
		spec_end = "-----END " + specifier + "-----"
		for line in f:
			line = line.rstrip()
			if (data is None) and (line == spec_begin):
				data = [ ]
			elif (data is not None) and (line == spec_end):
				break
			elif data is not None:
				data.append(line)
	if data is None:
		raise Exception("Trying to parse PEM file with specifier '%s', but no such block in file found." % (specifier))
	data = base64.b64decode("".join(data).encode("utf-8"))
	return data 

def user_has_perms(self, request):
        '''
            Check if user has permissions for the URL path and method in the request.
        '''
        path, user, method = (request.path, request.user, request.method,)
        #If it is not an API call, always return True
        if not path.startswith(API_BASE):
            return True
        #Return True for all GET requests
        if method == 'GET':
            return True
        #If request is POST, PUT or DELETE, check if user is authenticated. More fine-grained permissions checks can be handled here
        if method in ['POST', 'PUT', 'DELETE']:

            if not user.is_authenticated():
                #If user is not authenticated by session var, check for http basic
                if 'HTTP_AUTHORIZATION' in request.META:
                    auth = request.META['HTTP_AUTHORIZATION'].split()
                    if len(auth) == 2:
                        if auth[0].lower() == "basic":
                            uname, passwd = base64.b64decode(auth[1]).split(':')
                            user = authenticate(username=uname, password=passwd)
                            if user is not None:
                                if user.is_active:
                                    login(request, user)
                                    request.user = user
                                    return True
                return False
            else:
                return True
        #Ideally, should never reach here. #QUESTION: perhaps we want to return False by default?
        return True