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)