def test_crack(self):
parent_xpub = b'xpub6BabMgRo8rKHfpAb8waRM5vj2AneD4kDMsJhm7jpBDHSJvrFAjHJHU5hM43YgsuJVUVHWacAcTsgnyRptfMdMP8b28LYfqGocGdKCFjhQMV'
child_xprv = b'xprv9xkG88dGyiurKbVbPH1kjdYrA8poBBBXa53RKuRGJXyruuoJUDd8e4m6poiz7rV8Z4NoM5AJNcPHN6aj8wRFt5CWvF8VPfQCrDUcLU5tcTm'
parent_xprv = crack_prvkey(parent_xpub, child_xprv)
self.assertEqual(xpub_from_xprv(parent_xprv), parent_xpub)
# same check with XKeyDict
parent_xprv = crack_prvkey(deserialize(parent_xpub),
deserialize(child_xprv))
self.assertEqual(xpub_from_xprv(parent_xprv), parent_xpub)
# extended parent key is not a public one
self.assertRaises(ValueError, crack_prvkey, parent_xprv, child_xprv)
#crack_prvkey(parent_xprv, child_xprv)
# extended child key is not a private one
self.assertRaises(ValueError, crack_prvkey, parent_xpub, parent_xpub)
#crack_prvkey(parent_xpub, parent_xpub)
# wrong child/parent depth relation
child_xpub = xpub_from_xprv(child_xprv)
self.assertRaises(ValueError, crack_prvkey, child_xpub, child_xprv)
#crack_prvkey(child_xpub, child_xprv)
# not a child for the provided parent
child0_xprv = derive(parent_xprv, 0)
grandchild_xprv = derive(child0_xprv, 0)
self.assertRaises(ValueError, crack_prvkey, child_xpub,
grandchild_xprv)
#crack_prvkey(child_xpub, grandchild_xprv)
# hardened derivation
hardened_child_xprv = derive(parent_xprv, 0x80000000)
self.assertRaises(ValueError, crack_prvkey, parent_xpub,
hardened_child_xprv)
def test_exceptions() -> None:
with pytest.raises(ValueError, match="not a private or public key: "):
# invalid checksum
xprv = "xppp9s21ZrQH143K2oxHiQ5f7D7WYgXD9h6HAXDBuMoozDGGiYHWsq7TLBj2yvGuHTLSPCaFmUyN1v3fJRiY2A4YuNSrqQMPVLZKt76goL6LP7L"
p2pkh(xprv)
xpub = "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"
with pytest.raises(ValueError, match="not a private key: "):
bip32.xpub_from_xprv(xpub)
xpub_dict = bip32.deserialize(xpub)
xpub_dict = bip32.deserialize(xpub_dict)
xpub_dict["chain_code"] = (xpub_dict["chain_code"])[:-1]
with pytest.raises(ValueError, match="invalid chain code length: "):
xpub_dict = bip32.deserialize(xpub_dict)
xpub_dict = bip32.deserialize(xpub)
xpub_dict[
"chain_code"] = "length is 32 but not a chaincode" # type: ignore
with pytest.raises(ValueError, match="invalid chain code"):
xpub_dict = bip32.deserialize(xpub_dict)
seed = "5b56c417303faa3fcba7e57400e120a0"
with pytest.raises(ValueError, match="unknown private key version: "):
version = b"\x04\x88\xAD\xE5"
bip32.rootxprv_from_seed(seed, version)
with pytest.raises(ValueError, match="too many bits for seed: "):
bip32.rootxprv_from_seed(seed * 5)
with pytest.raises(ValueError, match="too few bits for seed: "):
bip32.rootxprv_from_seed(seed[:-2])
def test_crack():
parent_xpub = "xpub6BabMgRo8rKHfpAb8waRM5vj2AneD4kDMsJhm7jpBDHSJvrFAjHJHU5hM43YgsuJVUVHWacAcTsgnyRptfMdMP8b28LYfqGocGdKCFjhQMV"
child_xprv = "xprv9xkG88dGyiurKbVbPH1kjdYrA8poBBBXa53RKuRGJXyruuoJUDd8e4m6poiz7rV8Z4NoM5AJNcPHN6aj8wRFt5CWvF8VPfQCrDUcLU5tcTm"
parent_xprv = crack_prvkey(parent_xpub, child_xprv)
assert xpub_from_xprv(parent_xprv).decode() == parent_xpub
# same check with XKeyDict
parent_xprv = crack_prvkey(deserialize(parent_xpub), deserialize(child_xprv))
assert xpub_from_xprv(parent_xprv).decode() == parent_xpub
errmsg = "extended parent key is not a public key: "
with pytest.raises(ValueError, match=errmsg):
crack_prvkey(parent_xprv, child_xprv)
errmsg = "extended child key is not a private key: "
with pytest.raises(ValueError, match=errmsg):
crack_prvkey(parent_xpub, parent_xpub)
child_xpub = xpub_from_xprv(child_xprv)
with pytest.raises(ValueError, match="not a parent's child: wrong depths"):
crack_prvkey(child_xpub, child_xprv)
child0_xprv = derive(parent_xprv, 0)
grandchild_xprv = derive(child0_xprv, 0)
errmsg = "not a parent's child: wrong parent fingerprint"
with pytest.raises(ValueError, match=errmsg):
crack_prvkey(child_xpub, grandchild_xprv)
hardened_child_xprv = derive(parent_xprv, 0x80000000)
with pytest.raises(ValueError, match="hardened child derivation"):
crack_prvkey(parent_xpub, hardened_child_xprv)
def test_fingerprint(self):
xpub = "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8"
pf = fingerprint(xpub)
# bytes are used to increase code coverage
# dict is used to increase code coverage
xpubd = bip32.deserialize(xpub)
child_key = bip32.derive(xpubd, b'\x00' * 4)
pf2 = bip32.deserialize(child_key)['parent_fingerprint']
self.assertEqual(pf, pf2)
def test_invalid_bip32_xkeys():
filename = path.join(data_folder, "invalid_bip32_xkeys.json")
with open(filename, "r") as f:
test_vectors = json.load(f)
for xkey, err_msg in test_vectors:
with pytest.raises(ValueError, match=err_msg):
deserialize(xkey)
def test_fingerprint(self):
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
f = fingerprint(xprv)
child_key = derive(xprv, b'\x00\x00\x00\x00')
pf = deserialize(child_key)['parent_fingerprint']
self.assertEqual(f, pf)
xpub = xpub_from_xprv(xprv)
f = fingerprint(xpub)
self.assertEqual(f, pf)
child_key2 = derive(deserialize(xprv), 0)
self.assertEqual(child_key2, child_key)
def test_exceptions(self):
# Not a key for (testnet) network
xpub = (
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2g"
"Z29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8").encode()
xpubd = bip32.deserialize(xpub)
self.assertRaises(ValueError, _pubkeyinfo_from_xpub, xpubd, "testnet",
None)
# _pubkeyinfo_from_xpub(xpubd, 'testnet', None)
self.assertRaises(ValueError, _pubkeyinfo_from_xpub, xpubd, None,
False)
# _pubkeyinfo_from_xpub(xpubd, compressed=False)
xpub = (
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2g"
"Z29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8").encode()
self.assertRaises(ValueError, point_from_key, xpub, secp256r1)
wif = b"KzyziFNa2m2WC84NDBG2ix3rQXYcKHndvCjTkmJQWuoadpQxmdmu"
self.assertRaises(ValueError, point_from_key, wif, secp256r1)
# point_from_key(wif, secp256r1)
point_from_key(1, secp256r1)
def test_point_from_bip340pubkey() -> None:
q, x_Q = ssa.gen_keys()
P = mult(q)
# Integer (int)
assert ssa.point_from_bip340pubkey(x_Q) == P
# Integer (bytes)
assert ssa.point_from_bip340pubkey(x_Q.to_bytes(32, byteorder="big")) == P
# Integer (hex-str)
assert ssa.point_from_bip340pubkey(
x_Q.to_bytes(32, byteorder="big").hex()) == P
# tuple Point
assert ssa.point_from_bip340pubkey(P) == P
# 33 bytes
assert ssa.point_from_bip340pubkey(bytes_from_point(P)) == P
# 33 bytes hex-string
assert ssa.point_from_bip340pubkey(bytes_from_point(P).hex()) == P
# 65 bytes
assert ssa.point_from_bip340pubkey(bytes_from_point(P,
compressed=False)) == P
# 65 bytes hex-string
assert ssa.point_from_bip340pubkey(
bytes_from_point(P, compressed=False).hex()) == P
xpub_dict = bip32.deserialize(
"xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"
)
xpub_dict["key"] = bytes_from_point(P)
# BIP32KeyDict
assert ssa.point_from_bip340pubkey(xpub_dict) == P
# BIP32Key encoded str
xpub = bip32.serialize(xpub_dict)
assert ssa.point_from_bip340pubkey(xpub) == P
# BIP32Key str
assert ssa.point_from_bip340pubkey(xpub.decode()) == P
def test_serialize(self):
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xprv_dict = deserialize(xprv)
xpr2 = serialize(xprv_dict)
self.assertEqual(xpr2, xprv)
# private key not in [1, n-1]
inv_key = (ec.n).to_bytes(ec.nsize, 'big')
decoded_key = b58decode(xprv, 78)
xkey = b58encode(decoded_key[:46] + inv_key)
self.assertRaises(ValueError, deserialize, xkey)
# deserialize(xkey)
xpub = xpub_from_xprv(xprv)
xpub2 = xpub_from_xprv(deserialize(xprv))
self.assertEqual(xpub, xpub2)
def test_fingerprint():
xpub = "xpub661MyMwAqRbcFMYjmw8C6dJV97a4oLss6hb3v9wTQn2X48msQB61RCaLGtNhzgPCWPaJu7SvuB9EBSFCL43kTaFJC3owdaMka85uS154cEh"
pf = fingerprint(xpub)
child_key = bip32.derive(xpub, 0)
pf2 = bip32.deserialize(child_key)["parent_fingerprint"]
assert pf == pf2
def test_exceptions(self):
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprvd = bip32.deserialize(xprv)
# Compressed key provided, uncompressed key requested
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xprvd, "mainnet",
False)
# prvkeyinfo_from_prvkey(xprvd, 'mainnet', False)
# Mainnet key provided, testnet key requested
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xprvd, "testnet",
True)
# prvkeyinfo_from_prvkey(xprvd, 'testnet', True)
# Compression requirement mismatch
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xprv, "mainnet",
False)
# prvkeyinfo_from_prvkey(xprv, 'mainnet', False)
# Mainnet key provided, testnet key requested
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xprv, "testnet",
True)
def test_exceptions2(self):
rootxprv = b'xprv9s21ZrQH143K2ZP8tyNiUtgoezZosUkw9hhir2JFzDhcUWKz8qFYk3cxdgSFoCMzt8E2Ubi1nXw71TLhwgCfzqFHfM5Snv4zboSebePRmLS'
d = deserialize(rootxprv)
self.assertEqual(serialize(d), rootxprv)
# invalid 34-bytes key length
d['key'] += b'\x00'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# invalid 33-bytes chain_code length
d = deserialize(rootxprv)
d['chain_code'] += b'\x00'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# invalid 5-bytes parent_fingerprint length
d = deserialize(rootxprv)
d['parent_fingerprint'] += b'\x00'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# invalid 5-bytes index length
d = deserialize(rootxprv)
d['index'] += b'\x00'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# invalid depth (256)
d = deserialize(rootxprv)
d['depth'] = 256
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# zero depth with non-zero index b'\x00\x00\x00\x01'
d = deserialize(rootxprv)
d['index'] = b'\x00\x00\x00\x01'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# zero depth with non-zero parent_fingerprint b'\x00\x00\x00\x01'
d = deserialize(rootxprv)
d['parent_fingerprint'] = b'\x00\x00\x00\x01'
self.assertRaises(ValueError, serialize, d)
# serialize(d)
# non-zero depth (1) with zero parent_fingerprint b'\x00\x00\x00\x00'
xprv = deserialize(derive(rootxprv, 1))
xprv['parent_fingerprint'] = b'\x00\x00\x00\x00'
self.assertRaises(ValueError, serialize, xprv)
# serialize(xprv)
# int too big to convert
self.assertRaises(OverflowError, derive, rootxprv, 256**4)
# Index must be 4-bytes, not 5
self.assertRaises(ValueError, derive, rootxprv, b'\x00' * 5)
def test_fingerprint() -> None:
seed = "bfc4cbaad0ff131aa97fa30a48d09ae7df914bcc083af1e07793cd0a7c61a03f65d622848209ad3366a419f4718a80ec9037df107d8d12c19b83202de00a40ad"
xprv = bip32.rootxprv_from_seed(seed)
pf = fingerprint(xprv) # xprv is automatically converted to xpub
child_key = bip32.derive(xprv, 0x80000000)
pf2 = bip32.deserialize(child_key)["parent_fingerprint"]
assert pf == pf2
def test_deserialize():
xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xprv_dict = deserialize(xprv)
decoded_key = b58decode(xprv, 78)
assert xprv_dict["version"] == decoded_key[:4]
assert xprv_dict["depth"] == decoded_key[4]
assert xprv_dict["parent_fingerprint"] == decoded_key[5:9]
assert xprv_dict["index"] == decoded_key[9:13]
assert xprv_dict["chain_code"] == decoded_key[13:45]
assert xprv_dict["key"] == decoded_key[45:]
# no harm in deserializing again an already deserialized key
xprv_dict = deserialize(xprv_dict)
xpr2 = serialize(xprv_dict)
assert xpr2.decode(), xprv
xpub = xpub_from_xprv(xprv)
xpub2 = xpub_from_xprv(deserialize(xprv))
assert xpub == xpub2
def test_info_from_prvkey(self):
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprv_str = xprv.decode("ascii")
xprv_dict = bip32.deserialize(xprv)
wif = wif_from_prvkey(xprv)
wif_str = wif.decode("ascii")
ref_tuple = (xprv_dict["q"], "mainnet", True)
# BIP32
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv, "mainnet"))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv_str))
self.assertEqual(ref_tuple,
prvkeyinfo_from_prvkey(" " + xprv_str + " "))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv_dict))
# Invalid decoded size: 6 bytes instead of 82
xpub = "notakey"
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub)
# prvkeyinfo_from_prvkey(xpub)
# xkey is not a private one
xpub = (
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2g"
"Z29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8").encode()
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub)
# prvkeyinfo_from_prvkey(xpub)
# xkey is not a private one
xpub_dict = bip32.deserialize(xpub)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub_dict)
# prvkeyinfo_from_prvkey(xpub_dict)
# WIF keys (bytes or string)
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(wif))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(wif_str))
self.assertEqual(ref_tuple,
prvkeyinfo_from_prvkey(" " + wif_str + " "))
def test_utils(self):
# root key, zero depth
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xdict = deserialize(xprv)
decoded_key = b58decode(xprv, 78)
self.assertEqual(xdict["version"], decoded_key[:4])
self.assertEqual(xdict["depth"], decoded_key[4])
self.assertEqual(xdict["parent_fingerprint"], decoded_key[5:9])
self.assertEqual(xdict["index"], decoded_key[9:13])
self.assertEqual(xdict["chain_code"], decoded_key[13:45])
self.assertEqual(xdict["key"], decoded_key[45:])
# zero depth with non-zero parent_fingerprint
f2 = b'\x01\x01\x01\x01'
invalid_key = b58encode(xprv[:5] + f2 + xprv[9:])
self.assertRaises(ValueError, deserialize, invalid_key)
# deserialize(invalid_key)
# zero depth with non-zero index
i2 = b'\x01\x01\x01\x01'
invalid_key = b58encode(xprv[:9] + i2 + xprv[13:])
self.assertRaises(ValueError, deserialize, invalid_key)
# deserialize(invalid_key)
# non-zero depth (255) with zero parent_fingerprint
d2 = b'ff'
invalid_key = b58encode(xprv[:4] + d2 + xprv[5:])
self.assertRaises(ValueError, deserialize, invalid_key)
# deserialize(invalid_key)
child_key = derive(xprv, 0)
# Derivation path final depth 256>255
self.assertRaises(ValueError, derive, child_key, "." + 255 * "/0")
#derive(child_key, "."+255*"/0")
# Empty derivation path
self.assertRaises(ValueError, derive, child_key, "")
#derive(child_key, "")
# Invalid derivation path root: ";"
self.assertRaises(ValueError, derive, child_key, ";/0")
#derive(child_key, ";/0")
# Derivation path depth 256>255
self.assertRaises(ValueError, derive, child_key, "." + 256 * "/0")
#derive(child_key, "." + 256*"/0")
# xkey is not a public one
self.assertRaises(ValueError, p2pkh_from_xpub, xprv)
def test_serialize() -> None:
rootxprv = "xprv9s21ZrQH143K2ZP8tyNiUtgoezZosUkw9hhir2JFzDhcUWKz8qFYk3cxdgSFoCMzt8E2Ubi1nXw71TLhwgCfzqFHfM5Snv4zboSebePRmLS"
d = bip32.deserialize(rootxprv)
assert bip32.serialize(d).decode() == rootxprv
d["key"] += b"\x00"
with pytest.raises(ValueError, match="invalid key length: "):
bip32.serialize(d)
d = bip32.deserialize(rootxprv)
d["depth"] = 256
with pytest.raises(ValueError, match="invalid depth "):
bip32.serialize(d)
d = bip32.deserialize(rootxprv)
d["parent_fingerprint"] = b"\x00\x00\x00\x01"
errmsg = "zero depth with non-zero parent fingerprint 0x"
with pytest.raises(ValueError, match=errmsg):
bip32.serialize(d)
d = bip32.deserialize(rootxprv)
d["index"] = b"\x00\x00\x00\x01"
with pytest.raises(ValueError, match="zero depth with non-zero index 0x"):
bip32.serialize(d)
xprv = bip32.deserialize(bip32.derive(rootxprv, 0x80000000))
xprv["parent_fingerprint"] = b"\x00\x00\x00\x00"
errmsg = "zero parent fingerprint with non-zero depth "
with pytest.raises(ValueError, match=errmsg):
bip32.serialize(xprv)
d = bip32.deserialize(rootxprv)
d["parent_fingerprint"] += b"\x00"
with pytest.raises(ValueError,
match="invalid parent fingerprint length: "):
bip32.serialize(d)
d = bip32.deserialize(rootxprv)
d["index"] += b"\x00"
with pytest.raises(ValueError, match="invalid index length: "):
bip32.serialize(d)
d = bip32.deserialize(rootxprv)
d["chain_code"] += b"\x00"
with pytest.raises(ValueError, match="invalid chain code length: "):
bip32.serialize(d)
def test_to_prvkey_int(self):
# BIP32
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xprv_str = xprv.decode('ascii')
xprv_dict = bip32.deserialize(xprv)
# WIF
wif = wif_from_xprv(xprv)
wif_str = wif.decode('ascii')
# bytes
qbytes = xprv_dict['key'][1:]
qhex = qbytes.hex()
# int
q = xprv_dict['q']
self.assertEqual(q, to_prvkey_int(q))
# bytes
self.assertEqual(q, to_prvkey_int(qbytes))
self.assertRaises(ValueError, to_prvkey_int, b'\x00' + qbytes)
self.assertEqual(q, to_prvkey_int(qhex))
self.assertEqual(q, to_prvkey_int(' ' + qhex + ' '))
self.assertRaises(ValueError, to_prvkey_int, qhex + '00')
# WIF
self.assertEqual(q, to_prvkey_int(wif))
self.assertRaises(ValueError, to_prvkey_int, wif + b'\x00')
self.assertEqual(q, to_prvkey_int(wif_str))
self.assertEqual(q, to_prvkey_int(' ' + wif_str + ' '))
# BIP32
self.assertEqual(q, to_prvkey_int(xprv))
self.assertRaises(ValueError, to_prvkey_int, xprv + b'\x00')
self.assertEqual(q, to_prvkey_int(xprv_str))
self.assertEqual(q, to_prvkey_int(' ' + xprv_str + ' '))
self.assertEqual(q, to_prvkey_int(xprv_dict))
# wrong private key int
q = ec.n
self.assertRaises(ValueError, to_prvkey_int, q)
# bytes
qbytes = q.to_bytes(32, byteorder='big')
qhex = qbytes.hex()
self.assertRaises(ValueError, to_prvkey_int, qbytes)
self.assertRaises(ValueError, to_prvkey_int, qhex)
# WIF
t = b'\x80' + qbytes + b'\x01'
wif = b58encode(t)
wif_str = wif.decode('ascii')
self.assertRaises(ValueError, to_prvkey_int, wif)
self.assertRaises(ValueError, to_prvkey_int, wif_str)
# BIP32
t = xprv_dict['version']
t += xprv_dict['depth'].to_bytes(1, 'big')
t += xprv_dict['parent_fingerprint']
t += xprv_dict['index']
t += xprv_dict['chain_code']
t += b'\x00' + qbytes
xprv = b58encode(t)
xprv_str = xprv.decode('ascii')
self.assertRaises(ValueError, to_prvkey_int, xprv)
self.assertRaises(ValueError, to_prvkey_int, xprv_str)
# wrong private key int
q = 0
self.assertRaises(ValueError, to_prvkey_int, q)
# bytes
qbytes = q.to_bytes(32, byteorder='big')
qhex = qbytes.hex()
self.assertRaises(ValueError, to_prvkey_int, qbytes)
self.assertRaises(ValueError, to_prvkey_int, qhex)
# WIF
t = b'\x80' + qbytes + b'\x01'
wif = b58encode(t)
wif_str = wif.decode('ascii')
self.assertRaises(ValueError, to_prvkey_int, wif)
self.assertRaises(ValueError, to_prvkey_int, wif_str)
# BIP32
t = xprv_dict['version']
t += xprv_dict['depth'].to_bytes(1, 'big')
t += xprv_dict['parent_fingerprint']
t += xprv_dict['index']
t += xprv_dict['chain_code']
t += b'\x00' + qbytes
xprv = b58encode(t)
xprv_str = xprv.decode('ascii')
self.assertRaises(ValueError, to_prvkey_int, xprv)
self.assertRaises(ValueError, to_prvkey_int, xprv_str)
# pub key
xpub = b'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8'
self.assertRaises(ValueError, to_prvkey_int, xpub)
def test_bytes_from_key(self):
# prvkeys
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xprv_str = xprv.decode('ascii')
xprv_dict = bip32.deserialize(xprv)
q, network, _ = _prvkey_info_from_xprv(xprv)
ec = curve_from_network(network)
q_bytes = q.to_bytes(ec.psize, 'big')
wif1 = wif_from_prvkey(q, network, True)
wif2 = wif_from_prvkey(q, network, False)
# pubkeys
Q = mult(q, ec.G, ec)
xpub = bip32.xpub_from_xprv(xprv)
xpub_str = xpub.decode('ascii')
xpub_dict = bip32.deserialize(xpub)
Q_compr = xpub_dict['key']
Q_compr_hexstr = Q_compr.hex()
Q_uncompr = bytes_from_point(Q, ec, False)
Q_uncompr_hexstr = Q_uncompr.hex()
# int prvkey, compressed result
self.assertEqual(bytes_from_key(q)[0], Q_compr)
self.assertEqual(bytes_from_key(q_bytes)[0], Q_compr)
# int prvkey, uncompressed result
self.assertEqual(bytes_from_key(q, compressed=False)[0], Q_uncompr)
self.assertEqual(bytes_from_key(
q_bytes, compressed=False)[0], Q_uncompr)
# compressed wif prvkey, both results
self.assertEqual(bytes_from_key(wif1)[0], Q_compr)
self.assertRaises(ValueError, bytes_from_key, wif1, compressed=False)
# uncompressed wif prvkey, both results
self.assertRaises(ValueError, bytes_from_key, wif2, compressed=True)
self.assertEqual(bytes_from_key(wif2)[0], Q_uncompr)
# (compressed) BIP32 prvkey, compressed results
self.assertEqual(bytes_from_key(xprv)[0], Q_compr)
self.assertEqual(bytes_from_key(xprv_str)[0], Q_compr)
self.assertEqual(bytes_from_key(' ' + xprv_str + ' ')[0], Q_compr)
self.assertEqual(bytes_from_key(xprv_dict)[0], Q_compr)
# (compressed) BIP32 prvkey, uncompressed result
self.assertRaises(ValueError, bytes_from_key, xprv, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
xprv_str, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
' ' + xprv_str + ' ', compressed=False)
self.assertRaises(ValueError, bytes_from_key,
xprv_dict, compressed=False)
# (compressed) BIP32 pubkey, compressed results
self.assertEqual(bytes_from_key(xpub)[0], Q_compr)
self.assertEqual(bytes_from_key(xpub_str)[0], Q_compr)
self.assertEqual(bytes_from_key(' ' + xpub_str + ' ')[0], Q_compr)
self.assertEqual(bytes_from_key(xpub_dict)[0], Q_compr)
# (compressed) BIP32 pubkey, uncompressed result
self.assertRaises(ValueError, bytes_from_key, xpub, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
xpub_str, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
' ' + xpub_str + ' ', compressed=False)
self.assertRaises(ValueError, bytes_from_key,
xpub_dict, compressed=False)
# compressed SEC Octets (pubkey), compressed results
self.assertEqual(bytes_from_key(Q_compr)[0], Q_compr)
self.assertEqual(bytes_from_key(Q_compr_hexstr)[0], Q_compr)
self.assertEqual(bytes_from_key(
' ' + Q_compr_hexstr + ' ')[0], Q_compr)
# compressed SEC Octets (pubkey), uncompressed results
self.assertRaises(ValueError, bytes_from_key,
Q_compr, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
Q_compr_hexstr, compressed=False)
self.assertRaises(ValueError, bytes_from_key,
' ' + Q_compr_hexstr + ' ', compressed=False)
self.assertRaises(ValueError, bytes_from_key, b'\x00' + Q_compr)
self.assertRaises(ValueError, bytes_from_key, Q_compr_hexstr + '00')
# uncompressed SEC Octets (pubkey), uncompressed results
self.assertEqual(bytes_from_key(Q_uncompr)[0], Q_uncompr)
self.assertEqual(bytes_from_key(Q_uncompr_hexstr)[0], Q_uncompr)
self.assertEqual(bytes_from_key(
' ' + Q_uncompr_hexstr + ' ')[0], Q_uncompr)
# uncompressed SEC Octets (pubkey), compressed results
self.assertRaises(ValueError, bytes_from_key,
Q_uncompr, compressed=True)
self.assertRaises(ValueError, bytes_from_key,
Q_uncompr_hexstr, compressed=True)
self.assertRaises(ValueError, bytes_from_key,
' ' + Q_uncompr_hexstr + ' ', compressed=True)
self.assertRaises(ValueError, bytes_from_key, b'\x00' + Q_uncompr)
self.assertRaises(ValueError, bytes_from_key, Q_uncompr_hexstr + '00')
# native tuple input, both results
self.assertEqual(bytes_from_key(Q)[0], Q_compr)
self.assertEqual(bytes_from_key(Q, compressed=False)[0], Q_uncompr)
# bytes_from_pubkey does not accept prvkey inputs
self.assertRaises(TypeError, bytes_from_pubkey, q)
self.assertRaises(ValueError, bytes_from_pubkey, q_bytes)
self.assertRaises(ValueError, bytes_from_pubkey, xprv)
self.assertRaises(ValueError, bytes_from_pubkey, xprv_str)
self.assertRaises(ValueError, bytes_from_pubkey, xprv_dict)
self.assertRaises(ValueError, bytes_from_pubkey, wif1)
self.assertRaises(ValueError, bytes_from_pubkey, wif2)
# Not a public key:
xpub_dict_bad = copy.copy(xpub_dict)
xpub_dict_bad['key'] = b'\x00' + xpub_dict['key'][1:]
self.assertRaises(ValueError, _bytes_from_xpub, xpub_dict_bad)
# _bytes_from_xpub(xpub_dict_bad)
# Invalid point: 7 is not a field element
Q = INF
self.assertRaises(ValueError, bytes_from_key, Q)
Q_compr = b'\x02' + Q[0].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, bytes_from_key, Q_compr)
Q_uncompr = b'\x04' + \
Q[0].to_bytes(ec.psize, 'big') + Q[1].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, bytes_from_key, Q_uncompr)
Q_compr_hexstr = Q_compr.hex()
self.assertRaises(ValueError, bytes_from_key, Q_compr_hexstr)
Q_uncompr_hexstr = Q_uncompr.hex()
self.assertRaises(ValueError, bytes_from_key, Q_uncompr_hexstr)
t = xpub_dict['version']
t += xpub_dict['depth'].to_bytes(1, 'big')
t += xpub_dict['parent_fingerprint']
t += xpub_dict['index']
t += xpub_dict['chain_code']
t += Q_compr
xpub = b58encode(t)
self.assertRaises(ValueError, bytes_from_key, xpub)
xpub_str = xpub.decode('ascii')
self.assertRaises(ValueError, bytes_from_key, xpub_str)
def test_pubkeyinfo_from_key(self):
# prvkeys
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprv_str = xprv.decode("ascii")
xprv_dict = bip32.deserialize(xprv)
q, network, _ = _prvkeyinfo_from_xprv(xprv)
ec = NETWORKS[network]["curve"]
q_bytes = q.to_bytes(ec.nsize, "big")
wif1 = wif_from_prvkey(q, network, True)
wif2 = wif_from_prvkey(q, network, False)
# pubkeys
Q = mult(q, ec.G, ec)
xpub = bip32.xpub_from_xprv(xprv)
xpub_str = xpub.decode("ascii")
xpub_dict = bip32.deserialize(xpub)
Q_compr = xpub_dict["key"]
Q_compr_hexstr = Q_compr.hex()
Q_uncompr = bytes_from_point(Q, ec, False)
Q_uncompr_hexstr = Q_uncompr.hex()
# int prvkey, compressed result
self.assertEqual(pubkeyinfo_from_key(q)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(q_bytes)[0], Q_compr)
# int prvkey, uncompressed result
self.assertEqual(
pubkeyinfo_from_key(q, compressed=False)[0], Q_uncompr)
self.assertEqual(
pubkeyinfo_from_key(q_bytes, compressed=False)[0], Q_uncompr)
# compressed wif prvkey, both results
self.assertEqual(pubkeyinfo_from_key(wif1)[0], Q_compr)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
wif1,
compressed=False)
# uncompressed wif prvkey, both results
self.assertRaises(ValueError,
pubkeyinfo_from_key,
wif2,
compressed=True)
self.assertEqual(pubkeyinfo_from_key(wif2)[0], Q_uncompr)
# (compressed) BIP32 prvkey, compressed results
self.assertEqual(pubkeyinfo_from_key(xprv)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(xprv_str)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(" " + xprv_str + " ")[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(xprv_dict)[0], Q_compr)
# (compressed) BIP32 prvkey, uncompressed result
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xprv,
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xprv_str,
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
" " + xprv_str + " ",
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xprv_dict,
compressed=False)
# (compressed) BIP32 pubkey, compressed results
self.assertEqual(pubkeyinfo_from_key(xpub)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(xpub_str)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(" " + xpub_str + " ")[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(xpub_dict)[0], Q_compr)
# (compressed) BIP32 pubkey, uncompressed result
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xpub,
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xpub_str,
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
" " + xpub_str + " ",
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
xpub_dict,
compressed=False)
# compressed SEC Octets (pubkey), compressed results
self.assertEqual(pubkeyinfo_from_key(Q_compr)[0], Q_compr)
self.assertEqual(pubkeyinfo_from_key(Q_compr_hexstr)[0], Q_compr)
self.assertEqual(
pubkeyinfo_from_key(" " + Q_compr_hexstr + " ")[0], Q_compr)
# compressed SEC Octets (pubkey), uncompressed results
self.assertRaises(ValueError,
pubkeyinfo_from_key,
Q_compr,
compressed=False)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
Q_compr_hexstr,
compressed=False)
self.assertRaises(
ValueError,
pubkeyinfo_from_key,
" " + Q_compr_hexstr + " ",
compressed=False,
)
self.assertRaises(ValueError, pubkeyinfo_from_key, b"\x00" + Q_compr)
self.assertRaises(ValueError, pubkeyinfo_from_key,
Q_compr_hexstr + "00")
# uncompressed SEC Octets (pubkey), uncompressed results
self.assertEqual(pubkeyinfo_from_key(Q_uncompr)[0], Q_uncompr)
self.assertEqual(pubkeyinfo_from_key(Q_uncompr_hexstr)[0], Q_uncompr)
self.assertEqual(
pubkeyinfo_from_key(" " + Q_uncompr_hexstr + " ")[0], Q_uncompr)
# uncompressed SEC Octets (pubkey), compressed results
self.assertRaises(ValueError,
pubkeyinfo_from_key,
Q_uncompr,
compressed=True)
self.assertRaises(ValueError,
pubkeyinfo_from_key,
Q_uncompr_hexstr,
compressed=True)
self.assertRaises(
ValueError,
pubkeyinfo_from_key,
" " + Q_uncompr_hexstr + " ",
compressed=True,
)
self.assertRaises(ValueError, pubkeyinfo_from_key, b"\x00" + Q_uncompr)
self.assertRaises(ValueError, pubkeyinfo_from_key,
Q_uncompr_hexstr + "00")
# native tuple input, both results
self.assertEqual(pubkeyinfo_from_key(Q)[0], Q_compr)
self.assertEqual(
pubkeyinfo_from_key(Q, compressed=False)[0], Q_uncompr)
# pubkeyinfo_from_pubkey does not accept prvkey inputs
self.assertRaises(TypeError, pubkeyinfo_from_pubkey, q)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, q_bytes)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, xprv)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, xprv_str)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, xprv_dict)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, wif1)
self.assertRaises(ValueError, pubkeyinfo_from_pubkey, wif2)
# Not a public key:
xpub_dict_bad = copy.copy(xpub_dict)
xpub_dict_bad["key"] = b"\x00" + xpub_dict["key"][1:]
self.assertRaises(ValueError, _pubkeyinfo_from_xpub, xpub_dict_bad)
# _pubkeyinfo_from_xpub(xpub_dict_bad)
# Invalid point: 7 is not a field element
Q = INF
self.assertRaises(ValueError, pubkeyinfo_from_key, Q)
Q_compr = b"\x02" + Q[0].to_bytes(ec.psize, "big")
self.assertRaises(ValueError, pubkeyinfo_from_key, Q_compr)
Q_uncompr = (b"\x04" + Q[0].to_bytes(ec.psize, "big") +
Q[1].to_bytes(ec.psize, "big"))
self.assertRaises(ValueError, pubkeyinfo_from_key, Q_uncompr)
Q_compr_hexstr = Q_compr.hex()
self.assertRaises(ValueError, pubkeyinfo_from_key, Q_compr_hexstr)
Q_uncompr_hexstr = Q_uncompr.hex()
self.assertRaises(ValueError, pubkeyinfo_from_key, Q_uncompr_hexstr)
t = xpub_dict["version"]
t += xpub_dict["depth"].to_bytes(1, "big")
t += xpub_dict["parent_fingerprint"]
t += xpub_dict["index"]
t += xpub_dict["chain_code"]
t += Q_compr
xpub = b58encode(t, 78)
self.assertRaises(ValueError, pubkeyinfo_from_key, xpub)
xpub_str = xpub.decode("ascii")
self.assertRaises(ValueError, pubkeyinfo_from_key, xpub_str)
from btclib import base58wif, bip32, bip39, btcmsg, der, slip32 from btclib.secpoint import bytes_from_point, point_from_octets from btclib.utils import bytes_from_octets mnemonic = "token output grass below such awake census safe orphan device other meat" passphrase = "" seed = bip39.seed_from_mnemonic(mnemonic, passphrase) rxprv = bip32.rootxprv_from_seed(seed) rxpub = bip32.xpub_from_xprv(rxprv) assert rxpub == b"xpub661MyMwAqRbcFzL26X6G7bySxgU1oV6GviUrNnhbeAS3ULQq35KEV6uSf1aJXEHjFYy6LXUPrYnfR9bSKWdFZ5VnYaEb3AbHPmXFVAoKKYT", rxpub firmware_xprv = bip32.derive(rxprv, "m/0") firmware_xpub = bip32.derive(rxpub, "m/0") assert firmware_xpub == bip32.xpub_from_xprv(bip32.derive(rxprv, "m/0")) firmware_pubkey = bip32.deserialize(firmware_xpub)['key'] assert bytes_from_point(point_from_octets(firmware_pubkey), False).hex( ) == "042374b3b6b06b65a3b831f857634ea135bf10b014d5bba0f935cb9eb26a4b6547ed3b37f277427a0ab23bda0ca79c5785dc54d2387fa3f295f4d5674d5b637de2" assert bytes_from_point(point_from_octets(firmware_pubkey), True).hex( ) == "022374b3b6b06b65a3b831f857634ea135bf10b014d5bba0f935cb9eb26a4b6547" firmware_wif = base58wif.wif_from_xprv(firmware_xprv) firmware_address = slip32.address_from_xpub(firmware_xpub) app_xprv = bip32.derive(rxprv, "m/1") app_xpub = bip32.derive(rxpub, "m/1") assert app_xpub == bip32.xpub_from_xprv(bip32.derive(rxprv, "m/1")) app_pubkey = bip32.deserialize(app_xpub)['key'] assert bytes_from_point(point_from_octets(app_pubkey), False).hex( ) == "04ae3d0d5c669ed364636e79e72abc012a33be63e537babddf56bfd393256acf6dba0fac21da6386513674573a2d7baff4375c9b6d2498383853c52f0565f97f1a" app_wif = base58wif.wif_from_xprv(app_xprv) app_address = slip32.address_from_xpub(app_xpub)
def test_int_from_prvkey(self):
# BIP32
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprv_str = xprv.decode("ascii")
xprv_dict = bip32.deserialize(xprv)
# WIF
wif = wif_from_prvkey(xprv)
wif_str = wif.decode("ascii")
# bytes
qbytes = xprv_dict["key"][1:]
qhex = qbytes.hex()
# int
q = xprv_dict["q"]
self.assertEqual(q, int_from_prvkey(q))
# bytes
self.assertEqual(q, int_from_prvkey(qbytes))
self.assertRaises(ValueError, int_from_prvkey, b"\x00" + qbytes)
self.assertEqual(q, int_from_prvkey(qhex))
self.assertEqual(q, int_from_prvkey(" " + qhex + " "))
self.assertRaises(ValueError, int_from_prvkey, qhex + "00")
# WIF
self.assertEqual(q, int_from_prvkey(wif))
self.assertRaises(ValueError, int_from_prvkey, wif + b"\x00")
self.assertEqual(q, int_from_prvkey(wif_str))
self.assertEqual(q, int_from_prvkey(" " + wif_str + " "))
# BIP32
self.assertEqual(q, int_from_prvkey(xprv))
self.assertRaises(ValueError, int_from_prvkey, xprv + b"\x00")
self.assertEqual(q, int_from_prvkey(xprv_str))
self.assertEqual(q, int_from_prvkey(" " + xprv_str + " "))
self.assertEqual(q, int_from_prvkey(xprv_dict))
# wrong private key int
q = ec.n
self.assertRaises(ValueError, int_from_prvkey, q)
# bytes
qbytes = q.to_bytes(32, byteorder="big")
qhex = qbytes.hex()
self.assertRaises(ValueError, int_from_prvkey, qbytes)
self.assertRaises(ValueError, int_from_prvkey, qhex)
# WIF
t = b"\x80" + qbytes + b"\x01"
wif = b58encode(t)
wif_str = wif.decode("ascii")
self.assertRaises(ValueError, int_from_prvkey, wif)
self.assertRaises(ValueError, int_from_prvkey, wif_str)
# BIP32
t = xprv_dict["version"]
t += xprv_dict["depth"].to_bytes(1, "big")
t += xprv_dict["parent_fingerprint"]
t += xprv_dict["index"]
t += xprv_dict["chain_code"]
t += b"\x00" + qbytes
xprv = b58encode(t, 78)
xprv_str = xprv.decode("ascii")
self.assertRaises(ValueError, int_from_prvkey, xprv)
self.assertRaises(ValueError, int_from_prvkey, xprv_str)
# wrong private key int
q = 0
self.assertRaises(ValueError, int_from_prvkey, q)
# bytes
qbytes = q.to_bytes(32, byteorder="big")
qhex = qbytes.hex()
self.assertRaises(ValueError, int_from_prvkey, qbytes)
self.assertRaises(ValueError, int_from_prvkey, qhex)
# WIF
t = b"\x80" + qbytes + b"\x01"
wif = b58encode(t)
wif_str = wif.decode("ascii")
self.assertRaises(ValueError, int_from_prvkey, wif)
self.assertRaises(ValueError, int_from_prvkey, wif_str)
# BIP32
t = xprv_dict["version"]
t += xprv_dict["depth"].to_bytes(1, "big")
t += xprv_dict["parent_fingerprint"]
t += xprv_dict["index"]
t += xprv_dict["chain_code"]
t += b"\x00" + qbytes
xprv = b58encode(t, 78)
xprv_str = xprv.decode("ascii")
self.assertRaises(ValueError, int_from_prvkey, xprv)
self.assertRaises(ValueError, int_from_prvkey, xprv_str)
# pub key
xpub = (
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2g"
"Z29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8").encode()
self.assertRaises(ValueError, int_from_prvkey, xpub)
def test_point_from_key(self):
# prvkeys
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprv_str = xprv.decode("ascii")
xprv_dict = bip32.deserialize(xprv)
q, network, _ = _prvkeyinfo_from_xprv(xprv)
ec = NETWORKS[network]["curve"]
q_bytes = q.to_bytes(ec.nsize, "big")
wif1 = wif_from_prvkey(q, network, True)
wif2 = wif_from_prvkey(q, network, False)
# pubkeys
Q = mult(q, ec.G, ec)
xpub = bip32.xpub_from_xprv(xprv)
xpub_str = xpub.decode("ascii")
xpub_dict = bip32.deserialize(xpub)
Q_compr = xpub_dict["key"]
Q_compr_hexstr = Q_compr.hex()
Q_uncompr = bytes_from_point(Q, ec, False)
Q_uncompr_hexstr = Q_uncompr.hex()
# int prvkey
self.assertEqual(point_from_key(q, ec), Q)
self.assertEqual(point_from_key(q_bytes, ec), Q)
# wif prvkey
self.assertEqual(point_from_key(wif1, ec), Q)
self.assertEqual(point_from_key(wif2, ec), Q)
# BIP32 prvkey
self.assertEqual(point_from_key(xprv, ec), Q)
self.assertEqual(point_from_key(xprv_str, ec), Q)
self.assertEqual(point_from_key(" " + xprv_str + " ", ec), Q)
self.assertEqual(point_from_key(xprv_dict, ec), Q)
# BIP32 pubkey
self.assertEqual(point_from_key(xpub, ec), Q)
self.assertEqual(point_from_key(xpub_str, ec), Q)
self.assertEqual(point_from_key(" " + xpub_str + " ", ec), Q)
self.assertEqual(point_from_key(xpub_dict, ec), Q)
# compressed SEC Octets (bytes or hex-string, with 02 or 03 prefix)
self.assertEqual(point_from_key(Q_compr, ec), Q)
self.assertRaises(ValueError, point_from_key, b"\x00" + Q_compr, ec)
self.assertEqual(point_from_key(Q_compr_hexstr, ec), Q)
self.assertEqual(point_from_key(" " + Q_compr_hexstr + " ", ec), Q)
self.assertRaises(ValueError, point_from_key, Q_compr_hexstr + "00",
ec)
# uncompressed SEC Octets (bytes or hex-string, with 04 prefix)
self.assertEqual(point_from_key(Q_uncompr, ec), Q)
self.assertRaises(ValueError, point_from_key, b"\x00" + Q_uncompr, ec)
self.assertEqual(point_from_key(Q_uncompr_hexstr, ec), Q)
self.assertEqual(point_from_key(" " + Q_uncompr_hexstr + " ", ec), Q)
self.assertRaises(ValueError, point_from_key, Q_uncompr_hexstr + "00",
ec)
# native tuple
self.assertEqual(point_from_key(Q, ec), Q)
# Invalid point: 7 is not a field element
Q = INF
self.assertRaises(ValueError, point_from_key, Q, ec)
Q_compr = b"\x02" + Q[0].to_bytes(ec.psize, "big")
self.assertRaises(ValueError, point_from_key, Q_compr, ec)
Q_uncompr = (b"\x04" + Q[0].to_bytes(ec.psize, "big") +
Q[1].to_bytes(ec.psize, "big"))
self.assertRaises(ValueError, point_from_key, Q_uncompr, ec)
Q_compr_hexstr = Q_compr.hex()
self.assertRaises(ValueError, point_from_key, Q_compr_hexstr, ec)
Q_uncompr_hexstr = Q_uncompr.hex()
self.assertRaises(ValueError, point_from_key, Q_uncompr_hexstr, ec)
t = xpub_dict["version"]
t += xpub_dict["depth"].to_bytes(1, "big")
t += xpub_dict["parent_fingerprint"]
t += xpub_dict["index"]
t += xpub_dict["chain_code"]
t += Q_compr
xpub = b58encode(t, 78)
self.assertRaises(ValueError, point_from_key, xpub, ec)
xpub_str = xpub.decode("ascii")
self.assertRaises(ValueError, point_from_key, xpub_str, ec)
# pubkey input
self.assertRaises(ValueError, point_from_pubkey, xprv, ec)
self.assertRaises(ValueError, point_from_pubkey, xprv_dict, ec)
def test_to_pub_bytes(self):
xpub = b'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8'
xpub_str = xpub.decode('ascii')
xpub_dict = bip32.deserialize(xpub)
P_compr = xpub_dict['key']
P_compr_hexstr = P_compr.hex()
P = xpub_dict['Q']
P_uncompr = bytes_from_point(P, False, ec)
P_uncompr_hexstr = P_uncompr.hex()
# BIP32 input, compressed result
self.assertEqual(to_pubkey_bytes(xpub, True, ec), P_compr)
self.assertEqual(to_pubkey_bytes(xpub_str, True, ec), P_compr)
self.assertEqual(to_pubkey_bytes(' ' + xpub_str + ' ', True, ec), P_compr)
self.assertEqual(to_pubkey_bytes(xpub_dict, True, ec), P_compr)
# compressed SEC Octets input, compressed result
self.assertEqual(to_pubkey_bytes(P_compr, True, ec), P_compr)
self.assertRaises(ValueError, to_pubkey_bytes, b'\x00' + P_compr, True, ec)
self.assertEqual(to_pubkey_bytes(P_compr_hexstr, True, ec), P_compr)
self.assertEqual(to_pubkey_bytes(' ' + P_compr_hexstr + ' ', True, ec), P_compr)
self.assertRaises(ValueError, to_pubkey_bytes, P_compr_hexstr + '00', True, ec)
# uncompressed SEC Octets input, compressed result
self.assertRaises(ValueError, to_pubkey_bytes, P_uncompr, True, ec)
self.assertRaises(ValueError, to_pubkey_bytes, P_uncompr_hexstr, True, ec)
self.assertRaises(ValueError, to_pubkey_bytes, ' ' + P_uncompr_hexstr + ' ', True, ec)
# native tuple input, compressed result
self.assertEqual(to_pubkey_bytes(P, True, ec), P_compr)
# BIP32 input, uncompressed result
self.assertRaises(ValueError, to_pubkey_bytes, xpub, False, ec)
self.assertRaises(ValueError, to_pubkey_bytes, xpub_str, False, ec)
self.assertRaises(ValueError, to_pubkey_bytes, ' ' + xpub_str + ' ', False, ec)
self.assertRaises(ValueError, to_pubkey_bytes, xpub_dict, False, ec)
# compressed SEC Octets input, uncompressed result
self.assertRaises(ValueError, to_pubkey_bytes, P_compr, False, ec)
self.assertRaises(ValueError, to_pubkey_bytes, P_compr_hexstr, False, ec)
self.assertRaises(ValueError, to_pubkey_bytes, ' ' + P_compr_hexstr + ' ', False, ec)
# uncompressed SEC Octets input, uncompressed result
self.assertEqual(to_pubkey_bytes(P_uncompr, False, ec), P_uncompr)
self.assertRaises(ValueError, to_pubkey_bytes, b'\x00' + P_uncompr, False, ec)
self.assertEqual(to_pubkey_bytes(P_uncompr_hexstr, False, ec), P_uncompr)
self.assertEqual(to_pubkey_bytes(' ' + P_uncompr_hexstr + ' ', False, ec), P_uncompr)
self.assertRaises(ValueError, to_pubkey_bytes, P_uncompr_hexstr + '00', False, ec)
# native tuple input, uncompressed result
self.assertEqual(to_pubkey_bytes(P, False, ec), P_uncompr)
# pubkey input
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
self.assertRaises(ValueError, to_pubkey_bytes, xprv, True, ec)
xprv_dict = bip32.deserialize(xprv)
self.assertRaises(ValueError, to_pubkey_bytes, xprv_dict, True, ec)
# Invalid point: 7 is not a field element
P = INF
self.assertRaises(ValueError, to_pubkey_bytes, P, True, ec)
P_compr = b'\x02' + P[0].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, to_pubkey_bytes, P_compr, True, ec)
P_uncompr = b'\x04' + P[0].to_bytes(ec.psize, 'big') + P[1].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, to_pubkey_bytes, P_uncompr, True, ec)
P_compr_hexstr = P_compr.hex()
self.assertRaises(ValueError, to_pubkey_bytes, P_compr_hexstr, True, ec)
P_uncompr_hexstr = P_uncompr.hex()
self.assertRaises(ValueError, to_pubkey_bytes, P_uncompr_hexstr, True, ec)
t = xpub_dict['version']
t += xpub_dict['depth'].to_bytes(1, 'big')
t += xpub_dict['parent_fingerprint']
t += xpub_dict['index']
t += xpub_dict['chain_code']
t += P_compr
xpub = b58encode(t)
self.assertRaises(ValueError, to_pubkey_bytes, xpub, True, ec)
xpub_str = xpub.decode('ascii')
self.assertRaises(ValueError, to_pubkey_bytes, xpub_str, True, ec)
def test_point_from_key(self):
# prvkeys
xprv = b"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"
xprv_str = xprv.decode('ascii')
xprv_dict = bip32.deserialize(xprv)
q, network, _ = _prvkey_info_from_xprv(xprv)
ec = curve_from_network(network)
q_bytes = q.to_bytes(ec.psize, 'big')
wif1 = wif_from_prvkey(q, network, True)
wif2 = wif_from_prvkey(q, network, False)
# pubkeys
Q = mult(q, ec.G, ec)
xpub = bip32.xpub_from_xprv(xprv)
xpub_str = xpub.decode('ascii')
xpub_dict = bip32.deserialize(xpub)
Q_compr = xpub_dict['key']
Q_compr_hexstr = Q_compr.hex()
Q_uncompr = bytes_from_point(Q, ec, False)
Q_uncompr_hexstr = Q_uncompr.hex()
# int prvkey
self.assertEqual(point_from_key(q, ec), Q)
self.assertEqual(point_from_key(q_bytes, ec), Q)
# wif prvkey
self.assertEqual(point_from_key(wif1, ec), Q)
self.assertEqual(point_from_key(wif2, ec), Q)
# BIP32 prvkey
self.assertEqual(point_from_key(xprv, ec), Q)
self.assertEqual(point_from_key(xprv_str, ec), Q)
self.assertEqual(point_from_key(' ' + xprv_str + ' ', ec), Q)
self.assertEqual(point_from_key(xprv_dict, ec), Q)
# BIP32 pubkey
self.assertEqual(point_from_key(xpub, ec), Q)
self.assertEqual(point_from_key(xpub_str, ec), Q)
self.assertEqual(point_from_key(' ' + xpub_str + ' ', ec), Q)
self.assertEqual(point_from_key(xpub_dict, ec), Q)
# compressed SEC Octets (bytes or hex-string, with 02 or 03 prefix)
self.assertEqual(point_from_key(Q_compr, ec), Q)
self.assertRaises(ValueError, point_from_key,
b'\x00' + Q_compr, ec)
self.assertEqual(point_from_key(Q_compr_hexstr, ec), Q)
self.assertEqual(point_from_key(' ' + Q_compr_hexstr + ' ', ec), Q)
self.assertRaises(ValueError, point_from_key,
Q_compr_hexstr + '00', ec)
# uncompressed SEC Octets (bytes or hex-string, with 04 prefix)
self.assertEqual(point_from_key(Q_uncompr, ec), Q)
self.assertRaises(ValueError, point_from_key,
b'\x00' + Q_uncompr, ec)
self.assertEqual(point_from_key(Q_uncompr_hexstr, ec), Q)
self.assertEqual(point_from_key(
' ' + Q_uncompr_hexstr + ' ', ec), Q)
self.assertRaises(ValueError, point_from_key,
Q_uncompr_hexstr + '00', ec)
# native tuple
self.assertEqual(point_from_key(Q, ec), Q)
# Invalid point: 7 is not a field element
Q = INF
self.assertRaises(ValueError, point_from_key, Q, ec)
Q_compr = b'\x02' + Q[0].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, point_from_key, Q_compr, ec)
Q_uncompr = b'\x04' + \
Q[0].to_bytes(ec.psize, 'big') + Q[1].to_bytes(ec.psize, 'big')
self.assertRaises(ValueError, point_from_key, Q_uncompr, ec)
Q_compr_hexstr = Q_compr.hex()
self.assertRaises(ValueError, point_from_key, Q_compr_hexstr, ec)
Q_uncompr_hexstr = Q_uncompr.hex()
self.assertRaises(ValueError, point_from_key, Q_uncompr_hexstr, ec)
t = xpub_dict['version']
t += xpub_dict['depth'].to_bytes(1, 'big')
t += xpub_dict['parent_fingerprint']
t += xpub_dict['index']
t += xpub_dict['chain_code']
t += Q_compr
xpub = b58encode(t)
self.assertRaises(ValueError, point_from_key, xpub, ec)
xpub_str = xpub.decode('ascii')
self.assertRaises(ValueError, point_from_key, xpub_str, ec)
# pubkey input
self.assertRaises(ValueError, point_from_pubkey, xprv, ec)
self.assertRaises(ValueError, point_from_pubkey, xprv_dict, ec)
