def is_mnemonic(mnemonic: str, language: Optional[str] = None) -> bool:
"""
Check mnemonic words.
:param mnemonic: Mnemonic words.
:type mnemonic: str
:param language: Mnemonic language, default to None.
:type language: str
:returns: bool -- Mnemonic valid/invalid.
>>> from swap.utils import is_mnemonic
>>> is_mnemonic(mnemonic="sceptre capter séquence girafe absolu relatif fleur zoologie muscle sirop saboter parure")
True
"""
if language and language not in ["english", "french", "italian", "japanese",
"chinese_simplified", "chinese_traditional", "korean", "spanish"]:
raise ValueError("invalid language, use only this options english, french, "
"italian, spanish, chinese_simplified, chinese_traditional, japanese or korean languages.")
try:
mnemonic = unicodedata.normalize("NFKD", mnemonic)
if language is None:
for _language in ["english", "french", "italian",
"chinese_simplified", "chinese_traditional", "japanese", "korean", "spanish"]:
valid = False
if Mnemonic(language=_language).check(mnemonic=mnemonic) is True:
valid = True
break
return valid
else:
return Mnemonic(language=language).check(mnemonic=mnemonic)
except:
return False
def get_mnemonic_language(mnemonic: str) -> str:
"""
Get mnemonic language.
:param mnemonic: Mnemonic words.
:type mnemonic: str
:returns: str -- Mnemonic language.
>>> from swap.utils import get_mnemonic_language
>>> get_mnemonic_language(mnemonic="sceptre capter séquence girafe absolu relatif fleur zoologie muscle sirop saboter parure")
"french"
"""
if not is_mnemonic(mnemonic=mnemonic):
raise ValueError("Invalid mnemonic words.")
language = None
mnemonic = unicodedata.normalize("NFKD", mnemonic)
for _language in ["english", "french", "italian",
"chinese_simplified", "chinese_traditional", "japanese", "korean", "spanish"]:
if Mnemonic(language=_language).check(mnemonic=mnemonic) is True:
language = _language
break
return language
def test_restore_keystore_from_mnemonic(tmpdir, mocker):
# Setup
spy = mocker.spy(Mnemonic, 'generate')
# Decrypt post-generation
keystore = Keystore.generate(INSECURE_DEVELOPMENT_PASSWORD, keystore_dir=tmpdir)
keystore.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
mnemonic = Mnemonic(_MNEMONIC_LANGUAGE)
words = spy.spy_return
secret = bytes(mnemonic.to_entropy(words))
keystore_path = keystore.keystore_path
# remove local and disk references, simulating a
# lost keystore or forgotten password.
del keystore
os.unlink(keystore_path)
# prove the keystore is lost or missing
assert not keystore_path.exists()
with pytest.raises(Keystore.NotFound):
_keystore = Keystore(keystore_path=keystore_path)
# Restore with user-supplied words and a new password
keystore = Keystore.restore(words=words, password='******')
keystore.unlock(password='******')
assert keystore._Keystore__secret == secret
def generate_mnemonic(language: str = "english", strength: int = 128) -> str:
"""
Generate mnemonic words.
:param language: Mnemonic language, default to english.
:type language: str
:param strength: Entropy strength, default to 128.
:type strength: int
:returns: str -- Mnemonic words.
>>> from swap.utils import generate_mnemonic
>>> generate_mnemonic(language="french")
"sceptre capter séquence girafe absolu relatif fleur zoologie muscle sirop saboter parure"
"""
if language and language not in ["english", "french", "italian", "japanese",
"chinese_simplified", "chinese_traditional", "korean", "spanish"]:
raise ValueError("invalid language, use only this options english, french, "
"italian, spanish, chinese_simplified, chinese_traditional, japanese or korean languages.")
if strength not in [128, 160, 192, 224, 256]:
raise ValueError(
"Strength should be one of the following "
"[128, 160, 192, 224, 256], but it is not (%d)."
% strength
)
return Mnemonic(language=language).generate(strength=strength)
def entropy_to_mnemonic(entropy: str, language: str = "english") -> str:
"""
Get mnemonic from entropy hex string.
:param entropy: Entropy hex string.
:type entropy: str
:param language: Mnemonic language, default to english.
:type language: str
:returns: str -- Mnemonic words.
>>> from swap.utils import entropy_to_mnemonic
>>> entropy_to_mnemonic(entropy="ee535b143b0d9d1f87546f9df0d06b1a", language="korean")
"학력 외침 주민 스위치 출연 연습 근본 여전히 울음 액수 귀신 마누라"
"""
if not is_entropy(entropy=entropy):
raise ValueError("Invalid entropy hex string.")
if language and language not in ["english", "french", "italian", "japanese",
"chinese_simplified", "chinese_traditional", "korean", "spanish"]:
raise ValueError("Invalid language, use only this options english, french, "
"italian, spanish, chinese_simplified, chinese_traditional, japanese or korean languages.")
return Mnemonic(language=language).to_mnemonic(unhexlify(entropy))
def controller_recover_key(recovery_phrase):
#function to recover a public and private key pair from a mnemonic phrase
mnemonic_base = Mnemonic(language='english')
seed = Mnemonic.to_seed(recovery_phrase)
privkey = bc.sha256(seed)
pubkey = bc.privkey_to_pubkey(privkey)
cpubkey = bc.compress(pubkey)
return privkey, cpubkey
def is_mnemonic(mnemonic: str, language: Optional[str] = None) -> bool:
"""
Check mnemonic words.
:param mnemonic: Mnemonic words.
:type mnemonic: str
:param language: Mnemonic language, default to None.
:type language: str
:returns: bool -- True/False.
>>> from pybytom.utils import is_mnemonic
>>> is_mnemonic("sceptre capter séquence girafe absolu relatif fleur zoologie muscle sirop saboter parure")
True
"""
if language and language not in [
"english", "french", "italian", "japanese", "chinese_simplified",
"chinese_traditional", "korean", "spanish"
]:
raise ValueError(
"Invalid language, choose only the following options 'english', 'french', 'italian', "
"'spanish', 'chinese_simplified', 'chinese_traditional', 'japanese or 'korean' languages."
)
try:
mnemonic = unicodedata.normalize("NFKD", mnemonic)
if language is None:
for _language in [
"english", "french", "italian", "chinese_simplified",
"chinese_traditional", "japanese", "korean", "spanish"
]:
valid = False
if Mnemonic(language=_language).check(
mnemonic=mnemonic) is True:
valid = True
break
return valid
else:
return Mnemonic(language=language).check(mnemonic=mnemonic)
except:
return False
def mnemonic_to_seed(mnemonic, pass_phrase=''):
"""Convert mnemonic (phrase) to seed
:param mnemonic: A phrase
:type mnemonic: str
:param pass_phrase: A password
:type pass_phrase: str
:returns: seed
"""
mnemo = Mnemonic("english")
seed = mnemo.to_seed(mnemonic, pass_phrase)
return seed
def restore(cls,
words: str,
password: str,
keystore_dir: Optional[Path] = None) -> 'Keystore':
"""Restore a keystore from seed words"""
__mnemonic = Mnemonic(_MNEMONIC_LANGUAGE)
__secret = bytes(__mnemonic.to_entropy(words))
path = Keystore.__save(secret=__secret,
password=password,
keystore_dir=keystore_dir)
keystore = cls(keystore_path=path)
return keystore
def master_key_from_entropy(passphrase='', language='english', strength=128):
if strength % 32 != 0:
raise ValueError("strength must be a multiple of 32")
if strength < 128 or strength > 256:
raise ValueError("strength should be >= 128 and <= 256")
entropy = CobraHDWallet.generate_entropy()
mnemonic = Mnemonic(language=language)\
.to_mnemonic(entropy)
return CobraHDWallet.master_key_from_seed(
Mnemonic.to_seed(mnemonic, passphrase)), mnemonic
def controller_keygen():
#function to generate a random mnemonic recovery phrase
#and in turn a private a public keys
decode_hex = codecs.getdecoder("hex_codec")
entropy_hex = bc.random_key()
entropy_bytes = decode_hex(entropy_hex)[0]
mnemonic_base = Mnemonic(language='english')
recovery_phrase = mnemonic_base.to_mnemonic(entropy_bytes)
seed = Mnemonic.to_seed(recovery_phrase)
privkey = bc.sha256(seed)
pubkey = bc.privkey_to_pubkey(privkey)
cpubkey = bc.compress(pubkey)
return privkey, cpubkey, recovery_phrase
def mnemonic_to_master(mnemonic, passphrase, netcode='BTC', check=True):
if check:
if not Mnemonic('english').check(mnemonic):
raise RuntimeError(
'mnemonic is non-standard, please check spelling')
seed = Mnemonic.to_seed(mnemonic, passphrase=passphrase)
if netcode == 'BTC':
master = btc.network.keys.bip32_seed(seed)
elif netcode == 'XTN':
master = xtn.network.keys.bip32_seed(seed)
else:
raise RuntimeError("unknown netcode")
return seed, master
def create_new_wallet(self, identifier, passphrase, key_index=0):
netcode = "XTN" if self.testnet else "BTC"
primary_mnemonic = Mnemonic(language='english').generate(strength=512)
primary_seed = Mnemonic.to_seed(primary_mnemonic, passphrase)
primary_private_key = BIP32Node.from_master_secret(primary_seed, netcode=netcode)
primary_public_key = primary_private_key.subkey_for_path("%d'.pub" % key_index)
backup_mnemonic = Mnemonic(language='english').generate(strength=512)
backup_seed = Mnemonic.to_seed(backup_mnemonic, "")
backup_public_key = BIP32Node.from_master_secret(backup_seed, netcode=netcode).public_copy()
checksum = self.create_checksum(primary_private_key)
result = self._create_new_wallet(
identifier=identifier,
primary_public_key=(primary_public_key.as_text(), "M/%d'" % key_index),
backup_public_key=(backup_public_key.as_text(), "M"),
primary_mnemonic=primary_mnemonic,
checksum=checksum,
key_index=key_index
)
blocktrail_public_keys = result['blocktrail_public_keys']
key_index = result['key_index']
return Wallet(
client=self,
identifier=identifier,
primary_mnemonic=primary_mnemonic,
primary_private_key=primary_private_key,
backup_public_key=backup_public_key,
blocktrail_public_keys=blocktrail_public_keys,
key_index=key_index,
testnet=self.testnet
), primary_mnemonic, backup_mnemonic, blocktrail_public_keys
def create(cls, mnemonic=None):
"""
Create Minter wallet
@param mnemonic|string: Mnemonic phrase
@return: dict
"""
# Create mnemonic phrase if None
if not mnemonic:
_mnemonic = Mnemonic(language='english')
mnemonic = _mnemonic.generate(cls.BIP44_ENTROPY_BITS)
if len(mnemonic.split(' ')) != 12:
raise Exception('Mnemonic phrase should have 12 words.')
# Mnemonic to seed (bytes)
seed = Mnemonic.to_seed(mnemonic, '')
# Generate master key from master seed
I = hmac.new(cls.MASTER_SEED, seed, hashlib.sha512).hexdigest()
IL = I[:64]
IR = I[64:]
master_key = HDPrivateKey(key=int.from_bytes(binascii.unhexlify(IL),
'big'),
chain_code=binascii.unhexlify(IR),
index=0,
depth=0)
# Get child keys from master key by path
keys = HDKey.from_path(master_key, cls.BIP44_SEED_ADDRESS_PATH)
# Get private key
private_key = binascii.hexlify(bytes(keys[-1]._key))
# Get public key
public_key = cls.get_public_from_private(private_key)
# Get address
address = cls.get_address_from_public_key(public_key)
return {
'address': address,
'private_key': private_key.decode(),
'mnemonic': mnemonic,
'seed': binascii.hexlify(seed).decode()
}
def test_decrypt_keystore(tmpdir, mocker):
# Setup
spy = mocker.spy(Mnemonic, 'generate')
# Decrypt post-generation
keystore = Keystore.generate(INSECURE_DEVELOPMENT_PASSWORD, keystore_dir=tmpdir)
keystore.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
mnemonic = Mnemonic(_MNEMONIC_LANGUAGE)
words = spy.spy_return
secret = bytes(mnemonic.to_entropy(words))
assert keystore._Keystore__secret == secret
# Decrypt from keystore file
keystore_path = keystore.keystore_path
del words
del keystore
keystore = Keystore(keystore_path=keystore_path)
keystore.unlock(INSECURE_DEVELOPMENT_PASSWORD)
assert keystore._Keystore__secret == secret
def generate(
cls,
password: str,
keystore_dir: Optional[Path] = None,
interactive: bool = True,
) -> Union['Keystore', Tuple['Keystore', str]]:
"""Generate a new nucypher keystore for use with characters"""
mnemonic = Mnemonic(_MNEMONIC_LANGUAGE)
__words = mnemonic.generate(strength=_ENTROPY_BITS)
if interactive:
cls._confirm_generate(__words)
__secret = bytes(mnemonic.to_entropy(__words))
path = Keystore.__save(secret=__secret,
password=password,
keystore_dir=keystore_dir)
keystore = cls(keystore_path=path)
if interactive:
return keystore
return keystore, __words
def create(cls, mnemonic=None):
"""
Create Minter wallet
Args:
mnemonic (str): Mnemonic phrase
Returns:
dict
"""
# Create mnemonic phrase if None
if not mnemonic:
_mnemonic = Mnemonic(language='english')
mnemonic = _mnemonic.generate(cls.entropy_bits)
if len(mnemonic.split(' ')) != 12:
raise Exception('Mnemonic phrase should have 12 words.')
# Mnemonic to seed (bytes)
seed = Mnemonic.to_seed(mnemonic, '')
# Generate master key (key, hmac_key) from master seed
_I = hmac.new(cls.master_seed, seed, hashlib.sha512).hexdigest()
master_key = (int(_I[:64], 16), bytes.fromhex(_I[64:]))
# Get child keys from master key by path
keys = cls.from_path(root_key=master_key, path=cls.seed_address_path)
# Get private key
private_key = format(keys[-1][0], '0x')
# Get public key from private
public_key = cls.get_public_from_private(private_key)
# Get address from public key
address = cls.get_address_from_public_key(public_key)
return {
'address': address,
'private_key': private_key,
'mnemonic': mnemonic,
'seed': seed.hex()
}
def mnemonic_to_entropy(mnemonic: str, language: Optional[str] = None) -> str:
"""
Get entropy from mnemonic words.
:param mnemonic: Mnemonic words.
:type mnemonic: str
:param language: Mnemonic language, default to english.
:type language: str
:returns: str -- Enropy hex string.
>>> from swap.utils import mnemonic_to_entropy
>>> mnemonic_to_entropy(mnemonic="학력 외침 주민 스위치 출연 연습 근본 여전히 울음 액수 귀신 마누라", language="korean")
"ee535b143b0d9d1f87546f9df0d06b1a"
"""
if not is_mnemonic(mnemonic=mnemonic, language=language):
raise ValueError("Invalid mnemonic words.")
mnemonic = unicodedata.normalize("NFKD", mnemonic)
language = language if language else get_mnemonic_language(mnemonic=mnemonic)
return Mnemonic(language=language).to_entropy(mnemonic).hex()
class TonlibTestAsyncCase2(unittest.TestCase):
keystore = os.path.join(proj_path, 'tmp')
vect = '23454927' * 5
local_password = '******'
key_password = '******'
mn = Mnemonic("english")
mn_phrase = mn.to_mnemonic(unhexlify(vect)).split(' ')
t = TonlibClientAsyncio(keystore=keystore)
def _create_new_key(self):
coro = self.t.create_new_key(local_password=self.local_password,
mnemonic=self.mn_phrase)
res = coro_result(coro)
self.assertIsInstance(res, dict)
self.assertEqual(res['@type'], 'key')
return res
def _delete_key(self, public_key, secret):
coro = self.t.delete_key(public_key=public_key, secret=secret)
res = coro_result(coro)
self.assertIsInstance(res, dict)
self.assertEqual(res['@type'], 'ok')
def setUp(self):
uvloop.install()
def test_export_key(self):
res_create_new_key = self._create_new_key()
coro_export_key = self.t.export_key(
public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'],
local_password=self.local_password)
res_export_key = coro_result(coro_export_key)
self.assertIsInstance(res_export_key, dict)
self.assertEqual(res_export_key['@type'], 'exportedKey')
self._delete_key(public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'])
def master_key_from_entropy(passphrase='', strength=128):
""" Generates a master key from system entropy.
Args:
strength (int): Amount of entropy desired. This should be
a multiple of 32 between 128 and 256.
passphrase (str): An optional passphrase for the generated
mnemonic string.
Returns:
HDPrivateKey, str:
a tuple consisting of the master
private key and a mnemonic string from which the seed
can be recovered.
"""
if strength % 32 != 0:
raise ValueError("strength must be a multiple of 32")
if strength < 128 or strength > 256:
raise ValueError("strength should be >= 128 and <= 256")
entropy = rand_bytes(strength // 8)
m = Mnemonic(language='english')
n = m.to_mnemonic(entropy)
return HDPrivateKey.master_key_from_seed(
Mnemonic.to_seed(n, passphrase)), n
def generate(data=None):
if data is None:
data = os.urandom(16)
return Mnemonic('english').to_mnemonic(data)
def check_master_key_from_mnemonic(mnemonic, language='english'):
try:
Mnemonic(language=language).check(mnemonic)
return True
except:
return False
#!/usr/bin/env python3
from shuttle.utils import sha256, double_sha256, \
generate_mnemonic, generate_passphrase
from mnemonic.mnemonic import Mnemonic
mnemonic = Mnemonic(language="korean")
def test_shuttle_utils():
assert sha256("meherett".encode()).hex() == \
"d4f5c55a45c004660b95ec833bb24569eba1559f214e90efa6e8d0b3afa14394"
assert double_sha256("meherett".encode()).hex() == \
"2803bf9ed1e5874825350b1b0753a96c00a99236b686bde337404453b11d3288"
generated_mnemonic = generate_mnemonic(language="korean")
assert mnemonic.check(generated_mnemonic)
assert len(generate_passphrase(length=100)) == 100
class ClientKeyingTestCase(unittest.TestCase):
keystore = os.path.join(proj_path, 'tmp')
vect = '23454927' * 5
local_password = '******'
key_password = '******'
mn = Mnemonic("english")
mn_phrase = mn.to_mnemonic(unhexlify(vect)).split(' ')
t = TonlibClientFutures(keystore=keystore)
def _create_new_key(self):
ft = self.t.create_new_key(local_password=self.local_password,
mnemonic=self.mn_phrase)
res = ft.result()
self.assertIsInstance(res, dict)
self.assertEqual('key', res['@type'])
return res
def _delete_key(self, public_key, secret):
ft = self.t.delete_key(public_key=public_key, secret=secret)
res = ft.result()
self.assertIsInstance(res, dict)
self.assertEqual('ok', res['@type'])
def test_create_new_key(self):
res_create_new_key = self.t.create_new_key(
local_password=self.local_password,
mnemonic=self.mn_phrase).result()
self.assertIsInstance(res_create_new_key, dict)
self.assertEqual('key', res_create_new_key['@type'])
self._delete_key(public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'])
def test_export_key(self):
res_create_new_key = self._create_new_key()
res_export_key = self.t.export_key(
public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'],
local_password=self.local_password).result()
self.assertIsInstance(res_export_key, dict)
self.assertEqual('exportedKey', res_export_key['@type'])
self._delete_key(public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'])
def _test_export_pem_key(self):
res_create_new_key = self._create_new_key()
res_export_pem_key = self.t.export_pem_key(
public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'],
local_password=self.local_password,
key_password=self.key_password).result()
self.assertIsInstance(res_export_pem_key, dict)
self.assertEqual('exportedKey', res_export_pem_key['@type'])
self._delete_key(public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'])
def test_export_encrypted_key(self):
res_create_new_key = self._create_new_key()
res_export_encrypted_key = self.t.export_encrypted_key(
public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'],
local_password=self.local_password,
key_password=self.key_password).result()
self.assertIsInstance(res_export_encrypted_key, dict)
self.assertEqual('exportedEncryptedKey',
res_export_encrypted_key['@type'])
self._delete_key(public_key=res_create_new_key['public_key'],
secret=res_create_new_key['secret'])
def _test_import_key(self):
res_import_key = self.t.import_key(local_password=self.local_password,
mnemonic_password=self.key_password,
mnemonic=self.mn_phrase).result()
self.assertIsInstance(res_import_key, dict)
self.assertEqual('key', res_import_key['@type'])
self._delete_key(public_key=res_import_key['public_key'],
secret=res_import_key['secret'])