def test_invalid_paths(self):
seed = binascii.unhexlify(b"000102030405060708090a0b0c0d0e0f")
for test in TEST_VECT_PATH_INVALID:
self.assertEqual([], Bip32PathParser.Parse(test["path"], test["skip_master"]))
# Try to derive an invalid path
bip32 = Bip32.FromSeed(seed)
self.assertRaises(Bip32PathError, bip32.DerivePath, test["path"])
# Try to construct from an invalid path (Bip32.FromSeedAndPath does not skip master)
if not test["skip_master"]:
self.assertRaises(Bip32PathError, Bip32.FromSeedAndPath, b"", test["path"])
def test_from_seed_with_derive_path(self):
for test in TEST_VECT_BIP32:
# Create from seed
bip32_ctx = Bip32.FromSeed(binascii.unhexlify(test["seed"]))
# Test master key
self.assertEqual(test["master"]["ex_pub"] , bip32_ctx.PublicKey().ToExtended())
self.assertEqual(test["master"]["ex_priv"], bip32_ctx.PrivateKey().ToExtended())
# Test derivation paths
for chain in test["der_paths"]:
# Update context
bip32_from_path = bip32_ctx.DerivePath(chain["path"][2:])
# Test keys
self.assertEqual(chain["ex_pub"] , bip32_from_path.PublicKey().ToExtended())
self.assertEqual(chain["ex_priv"], bip32_from_path.PrivateKey().ToExtended())
def test_from_seed_with_child_key(self):
for test in TEST_BIP32_MAIN:
# Create from seed
bip32_ctx = Bip32.FromSeed(binascii.unhexlify(test["seed"]))
# Test master key
self.assertEqual(test["master"]["ex_pub"],
bip32_ctx.PublicKey().ToExtended())
self.assertEqual(test["master"]["ex_priv"],
bip32_ctx.PrivateKey().ToExtended())
# Test derivation paths
for chain in test["der_paths"]:
# Update context
bip32_ctx = bip32_ctx.ChildKey(chain["index"])
# Test keys
self.assertEqual(chain["ex_pub"],
bip32_ctx.PublicKey().ToExtended())
self.assertEqual(chain["ex_priv"],
bip32_ctx.PrivateKey().ToExtended())
def mnemonic_to_private_key(mnemonic, network, pass_phrase=''):
"""Convert mnemonic (phrase) to a private key
:param mnemonic: A phrase
:type mnemonic: str
:param network: testnet or mainnet
:type mnemonic: str
:param pass_phrase: A password
:type pass_phrase: str
:returns: private key
"""
seed = mnemonic_to_seed(mnemonic, pass_phrase)
bip32_ctx = Bip32.FromSeed(seed)
HD_PATH = get_derive_path(
).testnet if network == "testnet" else get_derive_path().mainnet
hd_path = HD_PATH[2:]
bip32_ctx = bip32_ctx.DerivePath(hd_path)
priv_key = bip32_ctx.PrivateKey().Raw().ToHex()
return priv_key
def generate_uuid(mnemonic, passphrase=""):
# At this point the Cobo Vault hardware is directly using the (secret)
# BIP39 mnemonic, converting it to a BIP39 seed value. If one is using a
# Shamir (SLIP39) mnemonic a different path is taken to generate these
# seed bytes.
seed_bytes = Bip39SeedGenerator(mnemonic).Generate(passphrase)
# From this point onwards the code is identical whether a BIP39 or SLIP39
# mnemonic. The following extracts the BIP32 Root Key. This is still secret
# data that we don't want leaking from the Cobo Vault hardware.
bip32_root = Bip32.FromSeed(seed_bytes)
# Given the BIP32 root key, derive a BIP32 extended (public/private) keypair,
# using Cobo's BIP32 derivation path. Note that this path is only used for
# generating the 'UUID' used by the Cobo Vault (and app). For coin-specific
# (e.g. Bitcoin etc.) keys the Cobo Vault hardware and App use more typical
# hardened paths that are commonly used - E.g. m/49'/0'/0' for bitcoin,
# m/44'/60'/0' for Ethereum, etc. Still secret data here!
cobo_extend_key = (
bip32_root.ChildKey(Bip32Utils.HardenIndex(44))
.ChildKey(Bip32Utils.HardenIndex(1131373167))
.ChildKey(Bip32Utils.HardenIndex(0))
)
# Up until this point the Cobo Vault hardware has been dealing with secret
# information that should never be leaked outside the device, as doing so
# would allow stealing of one's keys and thus cryptocurrency. The next step
# discards the private key information and extracts the public key only. The
# public key can be used to find all transactions associated with a wallet, but
# it *cannot* be used to spend (or steal) cryptocurrency.
public_key = cobo_extend_key.PublicKey().RawCompressed().ToHex()
# After discarding the private (secret) key, compress the public key and remove
# a couple bytes to produce the 'uuid'.
uuid = public_key[2:]
return uuid
from avaxpython import Config
from avaxpython.utils.formatting.encoding import Encoding
from bip_utils import Bip32
import ref
import json
sample_wallet = next(generator.generate(1, Config.KEY_SIZE))
word_length = len(sample_wallet.split(" "))
if len(sys.argv) != word_length+1:
print("Invalid phrase length provided. Got {} expected {}.".format(len(sys.argv)-1, word_length))
exit(1)
seed = Mnemonic("english").to_seed(" ".join(sys.argv[1:]), passphrase="")
masterHdKey = Bip32.FromSeed(seed)
accountHdKey = Bip32.FromSeedAndPath(seed, WalletConfig.AVA_ACCOUNT_PATH)
# the first private key generated by an HD wallet seeded from this mnemonic phrase
firstHDKey = BIP32.derive_master_key(accountHdKey, '0/0')
masterKey = masterHdKey.PrivateKey().Raw().ToBytes()
accountKey = accountHdKey.PrivateKey().Raw().ToBytes()
firstKey = firstHDKey.PrivateKey().Raw().ToBytes()
enc = Encoding()
pkey_prefix = "PrivateKey-{}"
masterKeyEncoded = pkey_prefix.format(enc.Encode(masterKey))
accountKeyEncoded = pkey_prefix.format(enc.Encode(accountKey))
firstKeyEncoded = pkey_prefix.format(enc.Encode(firstKey))
from bip_utils import Bip32, Bip39SeedGenerator
from binascii import hexlify
if len(sys.argv) < 2 or sys.argv[1] == "":
print("No mnemonic given")
exit(1)
mnemonic = sys.argv[1]
words = mnemonic.split(" ")
print("BIP39 mnemonic starts with: {} {} ...".format(words[0], words[1]))
seed_bytes = Bip39SeedGenerator(mnemonic).Generate()
print("BIP39 seed: {}".format(hexlify(seed_bytes).decode("utf-8")))
bip32 = Bip32.FromSeed(seed_bytes)
print("BIP32 root key: {}".format(bip32.PrivateKey().ToExtended()))
derivation_path = "m/44'/60'/0'/0"
extended = Bip32.FromSeedAndPath(seed_bytes, derivation_path)
print("BIP32 extended public key: {}".format(
extended.PublicKey().ToExtended()))
print("BIP32 extended private key: {}".format(
extended.PrivateKey().ToExtended()))
derived_0_path = f"{derivation_path}/0"
derived_0_address = extended.DerivePath("0")
print("Derived {} public key: {}".format(
derived_0_path,
derived_0_address.EcdsaPublicKey().RawCompressed().ToHex()))
def key_from_seed(seed):
"""Return master private key from this seed"""
bip32_ctx = Bip32.FromSeed(seed)
return bip32_ctx