我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用base64.b16decode()。
def main(): usage = '''%(prog)s [--str="data"]''' parser = argparse.ArgumentParser(usage=usage) parser.add_argument('--str', action='store', type=str, dest='txt', help='The String Decode') parser.add_argument("--version", action="version", version="%(prog)s 1.0b") args = parser.parse_args() txt = args.txt if len(sys.argv) == 1: parser.print_help() sys.exet(1) try: msg = base64.b16decode(txt) print (color("[+] Base16: ", 2, 1) + "%s" % msg) except TypeError: print(color("\n[!] This data non-base16", 1, 1)) print(color("[*] Please try useage data with how2decoded-brute-force.py\n", 3, 1))
def from_ascii(s_ascii, prefix="", encoding="base64"): """This is the opposite of to_ascii. It will throw BadPrefixError if the prefix is not found. """ if isinstance(s_ascii, bytes): s_ascii = s_ascii.decode('ascii') if isinstance(prefix, bytes): prefix = prefix.decode('ascii') s_ascii = remove_prefix(s_ascii.strip(), prefix) if encoding == "base64": s_ascii += "="*((4 - len(s_ascii)%4)%4) s_bytes = base64.b64decode(s_ascii) elif encoding == "base32": s_ascii += "="*((8 - len(s_ascii)%8)%8) s_bytes = base64.b32decode(s_ascii.upper()) elif encoding in ("base16", "hex"): s_bytes = base64.b16decode(s_ascii.upper()) else: raise NotImplementedError return s_bytes
def load_config(): """Returns ClusterConfig object. Config contains task spec and cluster spec in dictionary-like form as below # {"task": {"index": 0, "type": "worker"}, "cluster": {"worker": ["localhost:24724"], "ps": ["localhost:15960"]}} """ # old way that doesn't work for sparse format # if 'TF_CONFIG' not in os.environ: # # try loading encoded version # if 'TF_CONFIG_BASE16' in os.environ: # tf_config_str = base64.b16decode(os.environ['TF_CONFIG_BASE16']) # tf_config_str = tf_config_str.decode('ascii') # os.environ['TF_CONFIG'] = tf_config_str # del os.environ['TF_CONFIG_BASE16'] # else: # assert False, "Must specify TF_CONFIG or TF_CONFIG_BASE16" # from tensorflow.contrib.learn.python.learn.estimators.run_config import ClusterConfig config = MyClusterConfig() config_dict = pickle.loads(base64.b16decode(os.environ["TF_PICKLE_BASE16"])) config.task_type = config_dict["task"]["type"] config.task_id = config_dict["task"]["index"] config.cluster_spec = config_dict["cluster"] return config
def test_b16decode(self): eq = self.assertEqual eq(base64.b16decode(b'0102ABCDEF'), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode('0102ABCDEF'), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode(b'00'), b'\x00') eq(base64.b16decode('00'), b'\x00') # Lower case is not allowed without a flag self.assertRaises(binascii.Error, base64.b16decode, b'0102abcdef') self.assertRaises(binascii.Error, base64.b16decode, '0102abcdef') # Case fold eq(base64.b16decode(b'0102abcdef', True), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode('0102abcdef', True), b'\x01\x02\xab\xcd\xef') # Non-bytes self.check_other_types(base64.b16decode, b"0102ABCDEF", b'\x01\x02\xab\xcd\xef') self.check_decode_type_errors(base64.b16decode) eq(base64.b16decode(bytearray(b"0102abcdef"), True), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode(memoryview(b"0102abcdef"), True), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode(array('B', b"0102abcdef"), True), b'\x01\x02\xab\xcd\xef')
def dnshostdecode(data): """ decodes DNS transmittable hostname data, 0-9A-F, ignoring casing :param data: DNS transmittable hostname data :return: decoded form """ # TODO: receiving 0-9A-Z would be better return base64.b16decode(data, casefold=True)
def _decode_bytes(key, format): """ internal TOTP() helper -- decodes key according to specified format. """ if format == "raw": if not isinstance(key, bytes): raise exc.ExpectedTypeError(key, "bytes", "key") return key # for encoded data, key must be either unicode or ascii-encoded bytes, # and must contain a hex or base32 string. key = to_unicode(key, param="key") key = _clean_re.sub("", key).encode("utf-8") # strip whitespace & hypens if format == "hex" or format == "base16": return base64.b16decode(key.upper()) elif format == "base32": return b32decode(key) # XXX: add base64 support? else: raise ValueError("unknown byte-encoding format: %r" % (format,)) #============================================================================= # OTP management #============================================================================= #: flag for detecting if encrypted totp support is present
def _decode_proc_address_encoding(addr): """ Translates an address entry in the /proc/net/* contents to a human readable form (`reference <http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html>`_, for instance: :: "0500000A:0016" -> ("10.0.0.5", 22) :param str addr: proc address entry to be decoded :returns: **tuple** of the form **(addr, port)**, with addr as a string and port an int """ ip, port = addr.split(':') # the port is represented as a two-byte hexadecimal number port = int(port, 16) if sys.version_info >= (3,): ip = ip.encode('ascii') # The IPv4 address portion is a little-endian four-byte hexadecimal number. # That is, the least significant byte is listed first, so we need to reverse # the order of the bytes to convert it to an IP address. # # This needs to account for the endian ordering as per... # http://code.google.com/p/psutil/issues/detail?id=201 # https://trac.torproject.org/projects/tor/ticket/4777 if sys.byteorder == 'little': ip = socket.inet_ntop(socket.AF_INET, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(socket.AF_INET, base64.b16decode(ip)) return (ip, port)
def retrieve_file_properties(self, name, path=None): m = REGEX_UPLOAD_PATTERN.match(name) if not m or not self.isattachment: raise TypeError('Can\'t retrieve %s file properties' % name) self_uploadfield = self.uploadfield if self.custom_retrieve_file_properties: return self.custom_retrieve_file_properties(name, path) if m.group('name'): try: filename = base64.b16decode(m.group('name'), True).decode('utf-8') filename = REGEX_CLEANUP_FN.sub('_', filename) except (TypeError, AttributeError): filename = name else: filename = name # ## if file is in DB if isinstance(self_uploadfield, (str, Field)): return dict(path=None, filename=filename) # ## if file is on filesystem if not path: if self.uploadfolder: path = self.uploadfolder else: path = pjoin(self.db._adapter.folder, '..', 'uploads') if self.uploadseparate: t = m.group('table') f = m.group('field') u = m.group('uuidkey') path = pjoin(path, "%s.%s" % (t, f), u[:2]) return dict(path=path, filename=filename)
def retrieve_file_properties(self, name, path=None): self_uploadfield = self.uploadfield if self.custom_retrieve_file_properties: return self.custom_retrieve_file_properties(name, path) try: m = REGEX_UPLOAD_PATTERN.match(name) if not m or not self.isattachment: raise TypeError('Can\'t retrieve %s file properties' % name) filename = base64.b16decode(m.group('name'), True) filename = REGEX_CLEANUP_FN.sub('_', filename) except (TypeError, AttributeError): filename = name if isinstance(self_uploadfield, str): # ## if file is in DB return dict(path=None,filename=filename) elif isinstance(self_uploadfield,Field): return dict(path=None,filename=filename) else: # ## if file is on filesystem if path: pass elif self.uploadfolder: path = self.uploadfolder else: path = pjoin(self.db._adapter.folder, '..', 'uploads') if self.uploadseparate: t = m.group('table') f = m.group('field') u = m.group('uuidkey') path = pjoin(path,"%s.%s" % (t,f),u[:2]) return dict(path=path,filename=filename)
def create_index_from_dir(stored_docs_dir,index_dir): indexer = Indexer() for filename in os.listdir(stored_docs_dir): opened_file = open(os.path.join(stored_docs_dir,filename)) doc_raw = html_to_text(opened_file.read()) parsed_doc = to_doc_terms(doc_raw) indexer.add_document(b16decode(filename),parsed_doc) indexer.store_on_desk(index_dir)
def test_b16decode(self): eq = self.assertEqual eq(base64.b16decode(b'0102ABCDEF'), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode(b'00'), b'\x00') # Lower case is not allowed without a flag self.assertRaises(binascii.Error, base64.b16decode, b'0102abcdef') # Case fold eq(base64.b16decode(b'0102abcdef', True), b'\x01\x02\xab\xcd\xef') self.assertRaises(TypeError, base64.b16decode, "")
def retrieve_file_properties(self, name, path=None): m = REGEX_UPLOAD_PATTERN.match(name) if not m or not self.isattachment: raise TypeError('Can\'t retrieve %s file properties' % name) self_uploadfield = self.uploadfield if self.custom_retrieve_file_properties: return self.custom_retrieve_file_properties(name, path) if m.group('name'): try: filename = base64.b16decode(m.group('name'), True) filename = REGEX_CLEANUP_FN.sub('_', filename) except (TypeError, AttributeError): filename = name else: filename = name # ## if file is in DB if isinstance(self_uploadfield, (str, Field)): return dict(path=None, filename=filename) # ## if file is on filesystem if not path: if self.uploadfolder: path = self.uploadfolder else: path = pjoin(self.db._adapter.folder, '..', 'uploads') if self.uploadseparate: t = m.group('table') f = m.group('field') u = m.group('uuidkey') path = pjoin(path, "%s.%s" % (t, f), u[:2]) return dict(path=path, filename=filename)
def test_b16decode(self): eq = self.assertEqual eq(base64.b16decode('0102ABCDEF'), '\x01\x02\xab\xcd\xef') eq(base64.b16decode('00'), '\x00') # Lower case is not allowed without a flag self.assertRaises(TypeError, base64.b16decode, '0102abcdef') # Case fold eq(base64.b16decode('0102abcdef', True), '\x01\x02\xab\xcd\xef') # Non-bytes eq(base64.b16decode(bytearray("0102ABCDEF")), '\x01\x02\xab\xcd\xef') # Non-alphabet characters self.assertRaises(TypeError, base64.b16decode, '0102AG') # Incorrect "padding" self.assertRaises(TypeError, base64.b16decode, '010')
def fromhex(s): return base64.b16decode(s.replace(' ', ''))
def _DecodeText(cls, packet_lines): packet_bytes = [] # First line is timestamp and stuff, skip it. # Format: 0x0010: 0000 0020 3aff 3ffe 0000 0000 0000 0000 ....:.?......... for line in packet_lines[1:]: m = re.match(r'\s+0x[a-f\d]+:\s+((?:[\da-f]{2,4}\s)*)', line, re.IGNORECASE) if m is None: continue for hexpart in m.group(1).split(): packet_bytes.append(base64.b16decode(hexpart.upper())) return ''.join(packet_bytes)
def test_b16decode(self): eq = self.assertEqual eq(base64.b16decode(b'0102ABCDEF'), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode('0102ABCDEF'), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode(b'00'), b'\x00') eq(base64.b16decode('00'), b'\x00') # Lower case is not allowed without a flag self.assertRaises(binascii.Error, base64.b16decode, b'0102abcdef') self.assertRaises(binascii.Error, base64.b16decode, '0102abcdef') # Case fold eq(base64.b16decode(b'0102abcdef', True), b'\x01\x02\xab\xcd\xef') eq(base64.b16decode('0102abcdef', True), b'\x01\x02\xab\xcd\xef') # Non-bytes eq(base64.b16decode(bytearray(b"0102ABCDEF")), b'\x01\x02\xab\xcd\xef')
def test_decode_nonascii_str(self): decode_funcs = (base64.b64decode, base64.standard_b64decode, base64.urlsafe_b64decode, base64.b32decode, base64.b16decode) for f in decode_funcs: self.assertRaises(ValueError, f, 'with non-ascii \xcb')
def _get_channel_bindings_value(server_certificate_hash): """ https://msdn.microsoft.com/en-us/library/windows/desktop/dd919963%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396 https://blogs.msdn.microsoft.com/openspecification/2013/03/26/ntlm-and-channel-binding-hash-aka-extended-protection-for-authentication/ Get's the MD5 hash of the gss_channel_bindings_struct to add to the AV_PAIR MSV_AV_CHANNEL_BINDINGS. This method takes in the SHA256 hash (Hash of the DER encoded certificate of the server we are connecting to) and add's it to the gss_channel_bindings_struct. It then gets the MD5 hash and converts this to a byte array in preparation of adding it to the AV_PAIR structure. :param server_certificate_hash: The SHA256 hash of the server certificate (DER encoded) NTLM is authenticated to :return channel_bindings: An MD5 hash of the gss_channel_bindings_struct to add to the AV_PAIR MsvChannelBindings """ # Channel Binding Tokens support, used for NTLMv2 # Decode the SHA256 certificate hash certificate_digest = base64.b16decode(server_certificate_hash) # Initialise the GssChannelBindingsStruct and add the certificate_digest to the application_data field gss_channel_bindings = GssChannelBindingsStruct() gss_channel_bindings[gss_channel_bindings.APPLICATION_DATA] = 'tls-server-end-point:'.encode() + certificate_digest # Get the gss_channel_bindings_struct and create an MD5 hash channel_bindings_struct_data = gss_channel_bindings.get_data() channel_bindings_hash = hashlib.md5(channel_bindings_struct_data).hexdigest() try: cbt_value = bytearray.fromhex(channel_bindings_hash) except TypeError: # Work-around for Python 2.6 bug cbt_value = bytearray.fromhex(unicode(channel_bindings_hash)) channel_bindings = bytes(cbt_value) return channel_bindings
def _decode_float(b16): return struct.unpack('d', base64.b16decode(b16))[0]
def test_b16decode(self): eq = self.assertEqual eq(base64.b16decode('0102ABCDEF'), '\x01\x02\xab\xcd\xef') eq(base64.b16decode('00'), '\x00') # Lower case is not allowed without a flag self.assertRaises(TypeError, base64.b16decode, '0102abcdef') # Case fold eq(base64.b16decode('0102abcdef', True), '\x01\x02\xab\xcd\xef') # Non-bytes eq(base64.b16decode(bytearray("0102ABCDEF")), '\x01\x02\xab\xcd\xef')
def base16(TEXT, choice): from base64 import b16encode, b16decode return b16encode(TEXT.encode('utf-8')).decode('utf-8') if choice == "encode" else b16decode(TEXT).decode("utf-8")
def test_decode_nonascii_str(self): decode_funcs = (base64.b64decode, base64.standard_b64decode, base64.urlsafe_b64decode, base64.b32decode, base64.b16decode, base64.b85decode, base64.a85decode) for f in decode_funcs: self.assertRaises(ValueError, f, 'with non-ascii \xcb')
def parse_str(encode_str, decode_method, *args, **kwargs): if len(encode_str) == 0: return False, encode_str try: if decode_method == 'base16': decode_str = b16decode(encode_str) elif decode_method == 'base32': decode_str = b32decode(encode_str) elif decode_method == 'binary': tmp = encode_str.replace('0', '').replace('1', '').strip() if tmp == '': # ???? 0xab1234???????? 0x decode_str = hex(int(encode_str, 2))[2:].rstrip('L') else: return False, encode_str else: decode_str = encode_str.decode(decode_method) # logger.info('%s: %s' % (decode_method, decode_str)) if len(decode_str) == 0: return False, encode_str else: return True, decode_str except Exception as e: # print(e) return False, encode_str
def decode(data): return base64.b16decode(data)
def from_share_id(cls, share_id): try: project_id, group_id = b16decode(share_id.upper()).split('.') except ValueError: raise cls.DoesNotExist return cls.objects.get(project=project_id, id=group_id)
def convert(str_data): if not isinstance(str_data, (str, unicode)): raise TypeError("expected String, got {}: {}".format(type(str_data), repr(str_data))) if all(x.isupper() for x in str_data): raise ParseError("base16 must be lower case: {}".format(repr(str_data))) if all(x.islower() for x in str_data) and all(x.isdigit() for x in str_data): raise ParseError("invalid base16: {}".format(repr(str_data))) if "=" in str_data: raise ParseError("padding disallowed: {}".format(str_data)) return base64.b16decode(str_data.upper())
def decode_address(self, addr, family): """Accept an "ip:port" address as displayed in /proc/net/* and convert it into a human readable form, like: "0500000A:0016" -> ("10.0.0.5", 22) "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521) The IP address portion is a little or big endian four-byte hexadecimal number; that is, the least significant byte is listed first, so we need to reverse the order of the bytes to convert it to an IP address. The port is represented as a two-byte hexadecimal number. Reference: http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html """ ip, port = addr.split(':') port = int(port, 16) # this usually refers to a local socket in listen mode with # no end-points connected if not port: return () if PY3: ip = ip.encode('ascii') if family == socket.AF_INET: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(family, base64.b16decode(ip)) else: # IPv6 # old version - let's keep it, just in case... # ip = ip.decode('hex') # return socket.inet_ntop(socket.AF_INET6, # ''.join(ip[i:i+4][::-1] for i in xrange(0, 16, 4))) ip = base64.b16decode(ip) try: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('>4I', *struct.unpack('<4I', ip))) else: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('<4I', *struct.unpack('<4I', ip))) except ValueError: # see: https://github.com/giampaolo/psutil/issues/623 if not supports_ipv6(): raise _Ipv6UnsupportedError else: raise return (ip, port)
def decode_address(addr, family): """Accept an "ip:port" address as displayed in /proc/net/* and convert it into a human readable form, like: "0500000A:0016" -> ("10.0.0.5", 22) "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521) The IP address portion is a little or big endian four-byte hexadecimal number; that is, the least significant byte is listed first, so we need to reverse the order of the bytes to convert it to an IP address. The port is represented as a two-byte hexadecimal number. Reference: http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html """ ip, port = addr.split(':') port = int(port, 16) # this usually refers to a local socket in listen mode with # no end-points connected if not port: return () if PY3: ip = ip.encode('ascii') if family == socket.AF_INET: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(family, base64.b16decode(ip)) else: # IPv6 # old version - let's keep it, just in case... # ip = ip.decode('hex') # return socket.inet_ntop(socket.AF_INET6, # ''.join(ip[i:i+4][::-1] for i in xrange(0, 16, 4))) ip = base64.b16decode(ip) try: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('>4I', *struct.unpack('<4I', ip))) else: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('<4I', *struct.unpack('<4I', ip))) except ValueError: # see: https://github.com/giampaolo/psutil/issues/623 if not supports_ipv6(): raise _Ipv6UnsupportedError else: raise return (ip, port)
def decode_address(self, addr, family): """Accept an "ip:port" address as displayed in /proc/net/* and convert it into a human readable form, like: "0500000A:0016" -> ("10.0.0.5", 22) "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521) The IP address portion is a little or big endian four-byte hexadecimal number; that is, the least significant byte is listed first, so we need to reverse the order of the bytes to convert it to an IP address. The port is represented as a two-byte hexadecimal number. Reference: http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html """ ip, port = addr.split(':') port = int(port, 16) # this usually refers to a local socket in listen mode with # no end-points connected if not port: return () if PY3: ip = ip.encode('ascii') if family == socket.AF_INET: # see: https://github.com/giampaolo/psutil/issues/201 if sys.byteorder == 'little': ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(family, base64.b16decode(ip)) else: # IPv6 # old version - let's keep it, just in case... # ip = ip.decode('hex') # return socket.inet_ntop(socket.AF_INET6, # ''.join(ip[i:i+4][::-1] for i in xrange(0, 16, 4))) ip = base64.b16decode(ip) try: # see: https://github.com/giampaolo/psutil/issues/201 if sys.byteorder == 'little': ip = socket.inet_ntop( socket.AF_INET6, struct.pack('>4I', *struct.unpack('<4I', ip))) else: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('<4I', *struct.unpack('<4I', ip))) except ValueError: # see: https://github.com/giampaolo/psutil/issues/623 if not supports_ipv6(): raise _Ipv6UnsupportedError else: raise return (ip, port)
