def get_pubkey_addresses( pubkey ): """ Get the compressed and uncompressed addresses for a public key. Useful for verifying signatures by key address. Return (compressed address, uncompressed address) """ public_key_object = ECPublicKey(pubkey) compressed_address = None uncompressed_address = None if public_key_object._type == PubkeyType.compressed: compressed_address = public_key_object.address() uncompressed_address = bin_hash160_to_address( bin_hash160( decompress(public_key_object.to_bin()) ) ) elif public_key_object._type == PubkeyType.uncompressed: compressed_address = bin_hash160_to_address( bin_hash160( compress(public_key_object.to_bin()) ) ) uncompressed_address = public_key_object.address() else: raise Exception("Invalid public key") return (compressed_address, uncompressed_address)
def get_pubkey_addresses( pubkey ): """ Get the compressed and uncompressed addresses for a public key. Useful for verifying signatures by key address. If we're running in testnet mode, then use the testnet version byte. Return (compressed address, uncompressed address) """ public_key_object = ECPublicKey(pubkey, version_byte=virtualchain.version_byte) compressed_address = None uncompressed_address = None if public_key_object._type == PubkeyType.compressed: compressed_address = public_key_object.address() uncompressed_address = bin_hash160_to_address( bin_hash160( decompress(public_key_object.to_bin()) ), version_byte=virtualchain.version_byte ) elif public_key_object._type == PubkeyType.uncompressed: compressed_address = bin_hash160_to_address( bin_hash160( compress(public_key_object.to_bin()) ), version_byte=virtualchain.version_byte ) uncompressed_address = public_key_object.address() else: raise Exception("Invalid public key") return (compressed_address, uncompressed_address)
def verify_token(token, public_key_or_address, signing_algorithm="ES256K"): """ A function for validating an individual token. """ decoded_token = decode_token(token) decoded_token_payload = decoded_token["payload"] if "subject" not in decoded_token_payload: raise ValueError("Token doesn't have a subject") if "publicKey" not in decoded_token_payload["subject"]: raise ValueError("Token doesn't have a subject public key") if "issuer" not in decoded_token_payload: raise ValueError("Token doesn't have an issuer") if "publicKey" not in decoded_token_payload["issuer"]: raise ValueError("Token doesn't have an issuer public key") if "claim" not in decoded_token_payload: raise ValueError("Token doesn't have a claim") issuer_public_key = str(decoded_token_payload["issuer"]["publicKey"]) public_key_object = ECPublicKey(issuer_public_key) compressed_public_key = compress(issuer_public_key) decompressed_public_key = decompress(issuer_public_key) if public_key_object._type == PubkeyType.compressed: compressed_address = public_key_object.address() uncompressed_address = bin_hash160_to_address( bin_hash160( decompress(public_key_object.to_bin()) ) ) elif public_key_object._type == PubkeyType.uncompressed: compressed_address = bin_hash160_to_address( bin_hash160( compress(public_key_object.to_bin()) ) ) uncompressed_address = public_key_object.address() else: raise ValueError("Invalid issuer public key format") if public_key_or_address == compressed_public_key: pass elif public_key_or_address == decompressed_public_key: pass elif public_key_or_address == compressed_address: pass elif public_key_or_address == uncompressed_address: pass else: raise ValueError("Token public key doesn't match the verifying value") token_verifier = TokenVerifier() if not token_verifier.verify(token, public_key_object.to_pem()): raise ValueError("Token was not signed by the issuer public key") return decoded_token
def verify_token(token, public_key_or_address, signing_algorithm="ES256K"): """ A function for validating an individual token. """ decoded_token = decode_token(token) decoded_token_payload = decoded_token["payload"] if "subject" not in decoded_token_payload: raise ValueError("Token doesn't have a subject") if "publicKey" not in decoded_token_payload["subject"]: raise ValueError("Token doesn't have a subject public key") if "issuer" not in decoded_token_payload: raise ValueError("Token doesn't have an issuer") if "publicKey" not in decoded_token_payload["issuer"]: raise ValueError("Token doesn't have an issuer public key") if "claim" not in decoded_token_payload: raise ValueError("Token doesn't have a claim") issuer_public_key = str(decoded_token_payload["issuer"]["publicKey"]) public_key_object = ECPublicKey(issuer_public_key) compressed_public_key = compress(issuer_public_key) decompressed_public_key = decompress(issuer_public_key) if public_key_object._type == PubkeyType.compressed: compressed_address = public_key_object.address() uncompressed_address = bin_hash160_to_address( bin_hash160(decompress(public_key_object.to_bin()))) elif public_key_object._type == PubkeyType.uncompressed: compressed_address = bin_hash160_to_address( bin_hash160(compress(public_key_object.to_bin()))) uncompressed_address = public_key_object.address() else: raise ValueError("Invalid issuer public key format") if public_key_or_address == compressed_public_key: pass elif public_key_or_address == decompressed_public_key: pass elif public_key_or_address == compressed_address: pass elif public_key_or_address == uncompressed_address: pass else: raise ValueError("Token public key doesn't match the verifying value") token_verifier = TokenVerifier() if not token_verifier.verify(token, public_key_object.to_pem()): raise ValueError("Token was not signed by the issuer public key") return decoded_token
def get_pubkey_addresses(pubkey): """ Get the compressed and uncompressed addresses for a public key. Useful for verifying signatures by key address. If we're running in testnet mode, then use the testnet version byte. Return (compressed address, uncompressed address) """ version_byte = virtualchain.version_byte compressed_address, uncompressed_address = None, None pubkey = ECPublicKey(pubkey, version_byte=version_byte) pubkey_bin = pubkey.to_bin() if pubkey._type == PubkeyType.compressed: compressed_address = pubkey.address() uncompressed_address = decompress(pubkey_bin) hashed_address = bin_hash160(uncompressed_address) uncompressed_address = bin_hash160_to_address( hashed_address, version_byte=version_byte) elif pubkey._type == PubkeyType.uncompressed: uncompressed_address = pubkey.address() compressed_address = compress(pubkey_bin) hashed_address = bin_hash160(compressed_address) compressed_address = bin_hash160_to_address(hashed_address, version_byte=version_byte) else: raise Exception('Invalid public key') return compressed_address, uncompressed_address
class BitcoinCompressedPublicKeyTest(unittest.TestCase): def setUp(self): self.reference = { 'hex_public_key': '02068fd9d47283fb310e6dfb66b141dd78fbabc76d073d48cddc770ffb2bd262d7', 'bin_public_key': '\x02\x06\x8f\xd9\xd4r\x83\xfb1\x0em\xfbf\xb1A\xddx\xfb\xab\xc7m\x07=H\xcd\xdcw\x0f\xfb+\xd2b\xd7', 'hex_hash160': '25488b0d3bb770d6e0ef07e1f19d33ab59931dee', 'bin_hash160': '%H\x8b\r;\xb7p\xd6\xe0\xef\x07\xe1\xf1\x9d3\xabY\x93\x1d\xee', 'address': '14Q8uVAX29RUMvqPGXL5sg6NiwwMRFCm8C', } self.public_key = ECPublicKey(self.reference['hex_public_key']) def tearDown(self): pass def test_address(self): self.assertEqual(self.public_key.address(), self.reference['address']) def test_bin_hash160(self): self.assertEqual( self.public_key.bin_hash160(), self.reference['bin_hash160']) def test_hex_hash160(self): self.assertEqual( self.public_key.hash160(), self.reference['hex_hash160']) def test_bin_public_key(self): self.assertEqual( self.public_key.to_bin(), self.reference['bin_public_key']) def test_hex_public_key(self): self.assertEqual( self.public_key.to_hex(), self.reference['hex_public_key'])
class BitcoinCompressedPublicKeyTest(unittest.TestCase): def setUp(self): self.reference = { 'hex_public_key': '02068fd9d47283fb310e6dfb66b141dd78fbabc76d073d48cddc770ffb2bd262d7', 'bin_public_key': '\x02\x06\x8f\xd9\xd4r\x83\xfb1\x0em\xfbf\xb1A\xddx\xfb\xab\xc7m\x07=H\xcd\xdcw\x0f\xfb+\xd2b\xd7', 'hex_hash160': '25488b0d3bb770d6e0ef07e1f19d33ab59931dee', 'bin_hash160': '%H\x8b\r;\xb7p\xd6\xe0\xef\x07\xe1\xf1\x9d3\xabY\x93\x1d\xee', 'address': '14Q8uVAX29RUMvqPGXL5sg6NiwwMRFCm8C', } self.public_key = ECPublicKey(self.reference['hex_public_key']) def tearDown(self): pass def test_address(self): self.assertEqual(self.public_key.address(), self.reference['address']) def test_bin_hash160(self): self.assertEqual(self.public_key.bin_hash160(), self.reference['bin_hash160']) def test_hex_hash160(self): self.assertEqual(self.public_key.hash160(), self.reference['hex_hash160']) def test_bin_public_key(self): self.assertEqual(self.public_key.to_bin(), self.reference['bin_public_key']) def test_hex_public_key(self): self.assertEqual(self.public_key.to_hex(), self.reference['hex_public_key'])
class BitcoinCompressedPublicKeyTest(unittest.TestCase): def setUp(self): self.ref = _compressed_info_2 self.public_key = ECPublicKey(self.ref['hex_public_key']) def tearDown(self): pass def test_address(self): self.assertEqual(self.public_key.address(), self.ref['address']) def test_bin_hash160(self): self.assertEqual(self.public_key.bin_hash160(), self.ref['bin_hash160']) def test_hex_hash160(self): self.assertEqual(self.public_key.hash160(), self.ref['hex_hash160']) def test_bin_public_key(self): self.assertEqual(self.public_key.to_bin(), self.ref['bin_public_key']) def test_hex_public_key(self): self.assertEqual(self.public_key.to_hex(), self.ref['hex_public_key'])