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
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 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 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
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 BitcoinUncompressedPublicKeyTest(unittest.TestCase):
reference = _reference_info
def setUp(self):
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_hex_hash160(self):
self.assertEqual(
self.public_key.hash160(), self.reference['hex_hash160'])
def test_hex_public_key(self):
self.assertEqual(
self.public_key.to_hex(), self.reference['hex_public_key'])
def test_pem_public_key(self):
self.assertEqual(
self.public_key.to_pem(), self.reference['pem_public_key'])
def test_der_public_key(self):
self.assertEqual(
self.public_key.to_der(), self.reference['der_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 BitcoinUncompressedPublicKeyTest(unittest.TestCase):
reference = _reference_info
def setUp(self):
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_hex_hash160(self):
self.assertEqual(self.public_key.hash160(),
self.reference['hex_hash160'])
def test_hex_public_key(self):
self.assertEqual(self.public_key.to_hex(),
self.reference['hex_public_key'])
def test_pem_public_key(self):
self.assertEqual(self.public_key.to_pem(),
self.reference['pem_public_key'])
def test_der_public_key(self):
self.assertEqual(self.public_key.to_der(),
self.reference['der_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'])
