Browse Source
- separation between Wallet and key management (Keystore) - simplification of wallet classes - remove support for multiple accounts in the same wallet - add support for OP_RETURN to Trezor plugin - split multi-accounts wallets for backward compatibility283
ThomasV
9 years ago
35 changed files with 1737 additions and 2052 deletions
@ -1,381 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# |
|
||||
# Electrum - lightweight Bitcoin client |
|
||||
# Copyright (C) 2013 thomasv@gitorious |
|
||||
# |
|
||||
# Permission is hereby granted, free of charge, to any person |
|
||||
# obtaining a copy of this software and associated documentation files |
|
||||
# (the "Software"), to deal in the Software without restriction, |
|
||||
# including without limitation the rights to use, copy, modify, merge, |
|
||||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|
||||
# and to permit persons to whom the Software is furnished to do so, |
|
||||
# subject to the following conditions: |
|
||||
# |
|
||||
# The above copyright notice and this permission notice shall be |
|
||||
# included in all copies or substantial portions of the Software. |
|
||||
# |
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
||||
# SOFTWARE. |
|
||||
|
|
||||
import bitcoin |
|
||||
from bitcoin import * |
|
||||
from i18n import _ |
|
||||
from transaction import Transaction, is_extended_pubkey |
|
||||
from util import InvalidPassword |
|
||||
|
|
||||
|
|
||||
class Account(object): |
|
||||
def __init__(self, v): |
|
||||
self.receiving_pubkeys = v.get('receiving', []) |
|
||||
self.change_pubkeys = v.get('change', []) |
|
||||
# addresses will not be stored on disk |
|
||||
self.receiving_addresses = map(self.pubkeys_to_address, self.receiving_pubkeys) |
|
||||
self.change_addresses = map(self.pubkeys_to_address, self.change_pubkeys) |
|
||||
|
|
||||
def dump(self): |
|
||||
return {'receiving':self.receiving_pubkeys, 'change':self.change_pubkeys} |
|
||||
|
|
||||
def get_pubkey(self, for_change, n): |
|
||||
pubkeys_list = self.change_pubkeys if for_change else self.receiving_pubkeys |
|
||||
return pubkeys_list[n] |
|
||||
|
|
||||
def get_address(self, for_change, n): |
|
||||
addr_list = self.change_addresses if for_change else self.receiving_addresses |
|
||||
return addr_list[n] |
|
||||
|
|
||||
def get_pubkeys(self, for_change, n): |
|
||||
return [ self.get_pubkey(for_change, n)] |
|
||||
|
|
||||
def get_addresses(self, for_change): |
|
||||
addr_list = self.change_addresses if for_change else self.receiving_addresses |
|
||||
return addr_list[:] |
|
||||
|
|
||||
def derive_pubkeys(self, for_change, n): |
|
||||
pass |
|
||||
|
|
||||
def create_new_address(self, for_change): |
|
||||
pubkeys_list = self.change_pubkeys if for_change else self.receiving_pubkeys |
|
||||
addr_list = self.change_addresses if for_change else self.receiving_addresses |
|
||||
n = len(pubkeys_list) |
|
||||
pubkeys = self.derive_pubkeys(for_change, n) |
|
||||
address = self.pubkeys_to_address(pubkeys) |
|
||||
pubkeys_list.append(pubkeys) |
|
||||
addr_list.append(address) |
|
||||
return address |
|
||||
|
|
||||
def pubkeys_to_address(self, pubkey): |
|
||||
return public_key_to_bc_address(pubkey.decode('hex')) |
|
||||
|
|
||||
def has_change(self): |
|
||||
return True |
|
||||
|
|
||||
def get_name(self, k): |
|
||||
return _('Main account') |
|
||||
|
|
||||
def redeem_script(self, for_change, n): |
|
||||
return None |
|
||||
|
|
||||
def is_used(self, wallet): |
|
||||
addresses = self.get_addresses(False) |
|
||||
return any(wallet.address_is_old(a, -1) for a in addresses) |
|
||||
|
|
||||
def synchronize_sequence(self, wallet, for_change): |
|
||||
limit = wallet.gap_limit_for_change if for_change else wallet.gap_limit |
|
||||
while True: |
|
||||
addresses = self.get_addresses(for_change) |
|
||||
if len(addresses) < limit: |
|
||||
address = self.create_new_address(for_change) |
|
||||
wallet.add_address(address) |
|
||||
continue |
|
||||
if map( lambda a: wallet.address_is_old(a), addresses[-limit:] ) == limit*[False]: |
|
||||
break |
|
||||
else: |
|
||||
address = self.create_new_address(for_change) |
|
||||
wallet.add_address(address) |
|
||||
|
|
||||
def synchronize(self, wallet): |
|
||||
self.synchronize_sequence(wallet, False) |
|
||||
self.synchronize_sequence(wallet, True) |
|
||||
|
|
||||
|
|
||||
class ImportedAccount(Account): |
|
||||
def __init__(self, d): |
|
||||
self.keypairs = d['imported'] |
|
||||
|
|
||||
def synchronize(self, wallet): |
|
||||
return |
|
||||
|
|
||||
def get_addresses(self, for_change): |
|
||||
return [] if for_change else sorted(self.keypairs.keys()) |
|
||||
|
|
||||
def get_pubkey(self, *sequence): |
|
||||
for_change, i = sequence |
|
||||
assert for_change == 0 |
|
||||
addr = self.get_addresses(0)[i] |
|
||||
return self.keypairs[addr][0] |
|
||||
|
|
||||
def get_xpubkeys(self, for_change, n): |
|
||||
return self.get_pubkeys(for_change, n) |
|
||||
|
|
||||
def get_private_key(self, sequence, wallet, password): |
|
||||
from wallet import pw_decode |
|
||||
for_change, i = sequence |
|
||||
assert for_change == 0 |
|
||||
address = self.get_addresses(0)[i] |
|
||||
pk = pw_decode(self.keypairs[address][1], password) |
|
||||
# this checks the password |
|
||||
if address != address_from_private_key(pk): |
|
||||
raise InvalidPassword() |
|
||||
return [pk] |
|
||||
|
|
||||
def has_change(self): |
|
||||
return False |
|
||||
|
|
||||
def add(self, address, pubkey, privkey, password): |
|
||||
from wallet import pw_encode |
|
||||
self.keypairs[address] = [pubkey, pw_encode(privkey, password)] |
|
||||
|
|
||||
def remove(self, address): |
|
||||
self.keypairs.pop(address) |
|
||||
|
|
||||
def dump(self): |
|
||||
return {'imported':self.keypairs} |
|
||||
|
|
||||
def get_name(self, k): |
|
||||
return _('Imported keys') |
|
||||
|
|
||||
def update_password(self, old_password, new_password): |
|
||||
for k, v in self.keypairs.items(): |
|
||||
pubkey, a = v |
|
||||
b = pw_decode(a, old_password) |
|
||||
c = pw_encode(b, new_password) |
|
||||
self.keypairs[k] = (pubkey, c) |
|
||||
|
|
||||
|
|
||||
class OldAccount(Account): |
|
||||
""" Privatekey(type,n) = Master_private_key + H(n|S|type) """ |
|
||||
|
|
||||
def __init__(self, v): |
|
||||
Account.__init__(self, v) |
|
||||
self.mpk = v['mpk'].decode('hex') |
|
||||
|
|
||||
@classmethod |
|
||||
def mpk_from_seed(klass, seed): |
|
||||
secexp = klass.stretch_key(seed) |
|
||||
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 ) |
|
||||
master_public_key = master_private_key.get_verifying_key().to_string().encode('hex') |
|
||||
return master_public_key |
|
||||
|
|
||||
@classmethod |
|
||||
def stretch_key(self,seed): |
|
||||
oldseed = seed |
|
||||
for i in range(100000): |
|
||||
seed = hashlib.sha256(seed + oldseed).digest() |
|
||||
return string_to_number( seed ) |
|
||||
|
|
||||
@classmethod |
|
||||
def get_sequence(self, mpk, for_change, n): |
|
||||
return string_to_number( Hash( "%d:%d:"%(n,for_change) + mpk ) ) |
|
||||
|
|
||||
def get_address(self, for_change, n): |
|
||||
pubkey = self.get_pubkey(for_change, n) |
|
||||
address = public_key_to_bc_address( pubkey.decode('hex') ) |
|
||||
return address |
|
||||
|
|
||||
@classmethod |
|
||||
def get_pubkey_from_mpk(self, mpk, for_change, n): |
|
||||
z = self.get_sequence(mpk, for_change, n) |
|
||||
master_public_key = ecdsa.VerifyingKey.from_string(mpk, curve = SECP256k1) |
|
||||
pubkey_point = master_public_key.pubkey.point + z*SECP256k1.generator |
|
||||
public_key2 = ecdsa.VerifyingKey.from_public_point(pubkey_point, curve = SECP256k1) |
|
||||
return '04' + public_key2.to_string().encode('hex') |
|
||||
|
|
||||
def derive_pubkeys(self, for_change, n): |
|
||||
return self.get_pubkey_from_mpk(self.mpk, for_change, n) |
|
||||
|
|
||||
def get_private_key_from_stretched_exponent(self, for_change, n, secexp): |
|
||||
order = generator_secp256k1.order() |
|
||||
secexp = ( secexp + self.get_sequence(self.mpk, for_change, n) ) % order |
|
||||
pk = number_to_string( secexp, generator_secp256k1.order() ) |
|
||||
compressed = False |
|
||||
return SecretToASecret( pk, compressed ) |
|
||||
|
|
||||
|
|
||||
def get_private_key(self, sequence, wallet, password): |
|
||||
seed = wallet.get_seed(password) |
|
||||
self.check_seed(seed) |
|
||||
for_change, n = sequence |
|
||||
secexp = self.stretch_key(seed) |
|
||||
pk = self.get_private_key_from_stretched_exponent(for_change, n, secexp) |
|
||||
return [pk] |
|
||||
|
|
||||
|
|
||||
def check_seed(self, seed): |
|
||||
secexp = self.stretch_key(seed) |
|
||||
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 ) |
|
||||
master_public_key = master_private_key.get_verifying_key().to_string() |
|
||||
if master_public_key != self.mpk: |
|
||||
print_error('invalid password (mpk)', self.mpk.encode('hex'), master_public_key.encode('hex')) |
|
||||
raise InvalidPassword() |
|
||||
return True |
|
||||
|
|
||||
def get_master_pubkeys(self): |
|
||||
return [self.mpk.encode('hex')] |
|
||||
|
|
||||
def get_type(self): |
|
||||
return _('Old Electrum format') |
|
||||
|
|
||||
def get_xpubkeys(self, for_change, n): |
|
||||
s = ''.join(map(lambda x: bitcoin.int_to_hex(x,2), (for_change, n))) |
|
||||
mpk = self.mpk.encode('hex') |
|
||||
x_pubkey = 'fe' + mpk + s |
|
||||
return [ x_pubkey ] |
|
||||
|
|
||||
@classmethod |
|
||||
def parse_xpubkey(self, x_pubkey): |
|
||||
assert is_extended_pubkey(x_pubkey) |
|
||||
pk = x_pubkey[2:] |
|
||||
mpk = pk[0:128] |
|
||||
dd = pk[128:] |
|
||||
s = [] |
|
||||
while dd: |
|
||||
n = int(bitcoin.rev_hex(dd[0:4]), 16) |
|
||||
dd = dd[4:] |
|
||||
s.append(n) |
|
||||
assert len(s) == 2 |
|
||||
return mpk, s |
|
||||
|
|
||||
|
|
||||
class BIP32_Account(Account): |
|
||||
|
|
||||
def __init__(self, v): |
|
||||
Account.__init__(self, v) |
|
||||
self.xpub = v['xpub'] |
|
||||
self.xpub_receive = None |
|
||||
self.xpub_change = None |
|
||||
|
|
||||
def dump(self): |
|
||||
d = Account.dump(self) |
|
||||
d['xpub'] = self.xpub |
|
||||
return d |
|
||||
|
|
||||
def first_address(self): |
|
||||
pubkeys = self.derive_pubkeys(0, 0) |
|
||||
addr = self.pubkeys_to_address(pubkeys) |
|
||||
return addr, pubkeys |
|
||||
|
|
||||
def get_master_pubkeys(self): |
|
||||
return [self.xpub] |
|
||||
|
|
||||
@classmethod |
|
||||
def derive_pubkey_from_xpub(self, xpub, for_change, n): |
|
||||
_, _, _, c, cK = deserialize_xkey(xpub) |
|
||||
for i in [for_change, n]: |
|
||||
cK, c = CKD_pub(cK, c, i) |
|
||||
return cK.encode('hex') |
|
||||
|
|
||||
def get_pubkey_from_xpub(self, xpub, for_change, n): |
|
||||
xpubs = self.get_master_pubkeys() |
|
||||
i = xpubs.index(xpub) |
|
||||
pubkeys = self.get_pubkeys(for_change, n) |
|
||||
return pubkeys[i] |
|
||||
|
|
||||
def derive_pubkeys(self, for_change, n): |
|
||||
xpub = self.xpub_change if for_change else self.xpub_receive |
|
||||
if xpub is None: |
|
||||
xpub = bip32_public_derivation(self.xpub, "", "/%d"%for_change) |
|
||||
if for_change: |
|
||||
self.xpub_change = xpub |
|
||||
else: |
|
||||
self.xpub_receive = xpub |
|
||||
_, _, _, c, cK = deserialize_xkey(xpub) |
|
||||
cK, c = CKD_pub(cK, c, n) |
|
||||
result = cK.encode('hex') |
|
||||
return result |
|
||||
|
|
||||
|
|
||||
def get_private_key(self, sequence, wallet, password): |
|
||||
out = [] |
|
||||
xpubs = self.get_master_pubkeys() |
|
||||
roots = [k for k, v in wallet.master_public_keys.iteritems() if v in xpubs] |
|
||||
for root in roots: |
|
||||
xpriv = wallet.get_master_private_key(root, password) |
|
||||
if not xpriv: |
|
||||
continue |
|
||||
_, _, _, c, k = deserialize_xkey(xpriv) |
|
||||
pk = bip32_private_key( sequence, k, c ) |
|
||||
out.append(pk) |
|
||||
return out |
|
||||
|
|
||||
def get_type(self): |
|
||||
return _('Standard 1 of 1') |
|
||||
|
|
||||
def get_xpubkeys(self, for_change, n): |
|
||||
# unsorted |
|
||||
s = ''.join(map(lambda x: bitcoin.int_to_hex(x,2), (for_change,n))) |
|
||||
xpubs = self.get_master_pubkeys() |
|
||||
return map(lambda xpub: 'ff' + bitcoin.DecodeBase58Check(xpub).encode('hex') + s, xpubs) |
|
||||
|
|
||||
@classmethod |
|
||||
def parse_xpubkey(self, pubkey): |
|
||||
assert is_extended_pubkey(pubkey) |
|
||||
pk = pubkey.decode('hex') |
|
||||
pk = pk[1:] |
|
||||
xkey = bitcoin.EncodeBase58Check(pk[0:78]) |
|
||||
dd = pk[78:] |
|
||||
s = [] |
|
||||
while dd: |
|
||||
n = int( bitcoin.rev_hex(dd[0:2].encode('hex')), 16) |
|
||||
dd = dd[2:] |
|
||||
s.append(n) |
|
||||
assert len(s) == 2 |
|
||||
return xkey, s |
|
||||
|
|
||||
def get_name(self, k): |
|
||||
return "Main account" if k == '0' else "Account " + k |
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
class Multisig_Account(BIP32_Account): |
|
||||
|
|
||||
def __init__(self, v): |
|
||||
self.m = v.get('m', 2) |
|
||||
Account.__init__(self, v) |
|
||||
self.xpub_list = v['xpubs'] |
|
||||
|
|
||||
def dump(self): |
|
||||
d = Account.dump(self) |
|
||||
d['xpubs'] = self.xpub_list |
|
||||
d['m'] = self.m |
|
||||
return d |
|
||||
|
|
||||
def get_pubkeys(self, for_change, n): |
|
||||
return self.get_pubkey(for_change, n) |
|
||||
|
|
||||
def derive_pubkeys(self, for_change, n): |
|
||||
return map(lambda x: self.derive_pubkey_from_xpub(x, for_change, n), self.get_master_pubkeys()) |
|
||||
|
|
||||
def redeem_script(self, for_change, n): |
|
||||
pubkeys = self.get_pubkeys(for_change, n) |
|
||||
return Transaction.multisig_script(sorted(pubkeys), self.m) |
|
||||
|
|
||||
def pubkeys_to_address(self, pubkeys): |
|
||||
redeem_script = Transaction.multisig_script(sorted(pubkeys), self.m) |
|
||||
address = hash_160_to_bc_address(hash_160(redeem_script.decode('hex')), 5) |
|
||||
return address |
|
||||
|
|
||||
def get_address(self, for_change, n): |
|
||||
return self.pubkeys_to_address(self.get_pubkeys(for_change, n)) |
|
||||
|
|
||||
def get_master_pubkeys(self): |
|
||||
return self.xpub_list |
|
||||
|
|
||||
def get_type(self): |
|
||||
return _('Multisig %d of %d'%(self.m, len(self.xpub_list))) |
|
||||
@ -0,0 +1,701 @@ |
|||||
|
#!/usr/bin/env python2 |
||||
|
# -*- mode: python -*- |
||||
|
# |
||||
|
# Electrum - lightweight Bitcoin client |
||||
|
# Copyright (C) 2016 The Electrum developers |
||||
|
# |
||||
|
# Permission is hereby granted, free of charge, to any person |
||||
|
# obtaining a copy of this software and associated documentation files |
||||
|
# (the "Software"), to deal in the Software without restriction, |
||||
|
# including without limitation the rights to use, copy, modify, merge, |
||||
|
# publish, distribute, sublicense, and/or sell copies of the Software, |
||||
|
# and to permit persons to whom the Software is furnished to do so, |
||||
|
# subject to the following conditions: |
||||
|
# |
||||
|
# The above copyright notice and this permission notice shall be |
||||
|
# included in all copies or substantial portions of the Software. |
||||
|
# |
||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
||||
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||||
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
||||
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
||||
|
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
||||
|
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
||||
|
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
|
# SOFTWARE. |
||||
|
|
||||
|
|
||||
|
from unicodedata import normalize |
||||
|
|
||||
|
from version import * |
||||
|
import bitcoin |
||||
|
from bitcoin import pw_encode, pw_decode, bip32_root, bip32_private_derivation, bip32_public_derivation, bip32_private_key, deserialize_xkey |
||||
|
from bitcoin import public_key_from_private_key, public_key_to_bc_address |
||||
|
from bitcoin import * |
||||
|
|
||||
|
from bitcoin import is_old_seed, is_new_seed |
||||
|
from util import PrintError, InvalidPassword |
||||
|
from mnemonic import Mnemonic |
||||
|
|
||||
|
|
||||
|
class KeyStore(PrintError): |
||||
|
|
||||
|
def has_seed(self): |
||||
|
return False |
||||
|
|
||||
|
def has_password(self): |
||||
|
return False |
||||
|
|
||||
|
def is_watching_only(self): |
||||
|
return False |
||||
|
|
||||
|
def can_import(self): |
||||
|
return False |
||||
|
|
||||
|
|
||||
|
class Software_KeyStore(KeyStore): |
||||
|
|
||||
|
def __init__(self): |
||||
|
KeyStore.__init__(self) |
||||
|
self.use_encryption = False |
||||
|
|
||||
|
def has_password(self): |
||||
|
return self.use_encryption |
||||
|
|
||||
|
|
||||
|
class Imported_KeyStore(Software_KeyStore): |
||||
|
# keystore for imported private keys |
||||
|
|
||||
|
def __init__(self): |
||||
|
Software_KeyStore.__init__(self) |
||||
|
self.keypairs = {} |
||||
|
|
||||
|
def is_deterministic(self): |
||||
|
return False |
||||
|
|
||||
|
def can_change_password(self): |
||||
|
return True |
||||
|
|
||||
|
def get_master_public_key(self): |
||||
|
return None |
||||
|
|
||||
|
def load(self, storage, name): |
||||
|
self.keypairs = storage.get('keypairs', {}) |
||||
|
self.use_encryption = storage.get('use_encryption', False) |
||||
|
self.receiving_pubkeys = self.keypairs.keys() |
||||
|
self.change_pubkeys = [] |
||||
|
|
||||
|
def save(self, storage, root_name): |
||||
|
storage.put('key_type', 'imported') |
||||
|
storage.put('keypairs', self.keypairs) |
||||
|
storage.put('use_encryption', self.use_encryption) |
||||
|
|
||||
|
def can_import(self): |
||||
|
return True |
||||
|
|
||||
|
def check_password(self, password): |
||||
|
self.get_private_key((0,0), password) |
||||
|
|
||||
|
def import_key(self, sec, password): |
||||
|
if not self.can_import(): |
||||
|
raise BaseException('This wallet cannot import private keys') |
||||
|
try: |
||||
|
pubkey = public_key_from_private_key(sec) |
||||
|
except Exception: |
||||
|
raise Exception('Invalid private key') |
||||
|
self.keypairs[pubkey] = sec |
||||
|
return pubkey |
||||
|
|
||||
|
def delete_imported_key(self, key): |
||||
|
self.keypairs.pop(key) |
||||
|
|
||||
|
def get_private_key(self, sequence, password): |
||||
|
for_change, i = sequence |
||||
|
assert for_change == 0 |
||||
|
pubkey = (self.change_pubkeys if for_change else self.receiving_pubkeys)[i] |
||||
|
pk = pw_decode(self.keypairs[pubkey], password) |
||||
|
# this checks the password |
||||
|
if pubkey != public_key_from_private_key(pk): |
||||
|
raise InvalidPassword() |
||||
|
return pk |
||||
|
|
||||
|
def update_password(self, old_password, new_password): |
||||
|
if old_password is not None: |
||||
|
self.check_password(old_password) |
||||
|
if new_password == '': |
||||
|
new_password = None |
||||
|
for k, v in self.keypairs.items(): |
||||
|
b = pw_decode(v, old_password) |
||||
|
c = pw_encode(b, new_password) |
||||
|
self.keypairs[k] = b |
||||
|
self.use_encryption = (new_password is not None) |
||||
|
|
||||
|
|
||||
|
class Deterministic_KeyStore(Software_KeyStore): |
||||
|
|
||||
|
def __init__(self): |
||||
|
Software_KeyStore.__init__(self) |
||||
|
self.seed = '' |
||||
|
|
||||
|
def is_deterministic(self): |
||||
|
return True |
||||
|
|
||||
|
def load(self, storage, name): |
||||
|
self.seed = storage.get('seed', '') |
||||
|
self.use_encryption = storage.get('use_encryption', False) |
||||
|
|
||||
|
def save(self, storage, name): |
||||
|
storage.put('seed', self.seed) |
||||
|
storage.put('use_encryption', self.use_encryption) |
||||
|
|
||||
|
def has_seed(self): |
||||
|
return self.seed != '' |
||||
|
|
||||
|
def can_change_password(self): |
||||
|
return not self.is_watching_only() |
||||
|
|
||||
|
def add_seed(self, seed, password): |
||||
|
if self.seed: |
||||
|
raise Exception("a seed exists") |
||||
|
self.seed_version, self.seed = self.format_seed(seed) |
||||
|
if password: |
||||
|
self.seed = pw_encode(self.seed, password) |
||||
|
self.use_encryption = (password is not None) |
||||
|
|
||||
|
def get_seed(self, password): |
||||
|
return pw_decode(self.seed, password).encode('utf8') |
||||
|
|
||||
|
|
||||
|
class Xpub: |
||||
|
|
||||
|
def __init__(self): |
||||
|
self.xpub = None |
||||
|
self.xpub_receive = None |
||||
|
self.xpub_change = None |
||||
|
|
||||
|
def add_master_public_key(self, xpub): |
||||
|
self.xpub = xpub |
||||
|
|
||||
|
def get_master_public_key(self): |
||||
|
return self.xpub |
||||
|
|
||||
|
def derive_pubkey(self, for_change, n): |
||||
|
xpub = self.xpub_change if for_change else self.xpub_receive |
||||
|
if xpub is None: |
||||
|
xpub = bip32_public_derivation(self.xpub, "", "/%d"%for_change) |
||||
|
if for_change: |
||||
|
self.xpub_change = xpub |
||||
|
else: |
||||
|
self.xpub_receive = xpub |
||||
|
_, _, _, c, cK = deserialize_xkey(xpub) |
||||
|
cK, c = CKD_pub(cK, c, n) |
||||
|
result = cK.encode('hex') |
||||
|
return result |
||||
|
|
||||
|
def get_xpubkey(self, c, i): |
||||
|
s = ''.join(map(lambda x: bitcoin.int_to_hex(x,2), (c, i))) |
||||
|
return 'ff' + bitcoin.DecodeBase58Check(self.xpub).encode('hex') + s |
||||
|
|
||||
|
|
||||
|
class BIP32_KeyStore(Deterministic_KeyStore, Xpub): |
||||
|
root_derivation = "m/" |
||||
|
|
||||
|
def __init__(self): |
||||
|
Xpub.__init__(self) |
||||
|
Deterministic_KeyStore.__init__(self) |
||||
|
self.xprv = None |
||||
|
|
||||
|
def format_seed(self, seed): |
||||
|
return NEW_SEED_VERSION, ' '.join(seed.split()) |
||||
|
|
||||
|
def load(self, storage, name): |
||||
|
Deterministic_KeyStore.load(self, storage, name) |
||||
|
self.xpub = storage.get('master_public_keys', {}).get(name) |
||||
|
self.xprv = storage.get('master_private_keys', {}).get(name) |
||||
|
|
||||
|
def save(self, storage, name): |
||||
|
Deterministic_KeyStore.save(self, storage, name) |
||||
|
d = storage.get('master_public_keys', {}) |
||||
|
d[name] = self.xpub |
||||
|
storage.put('master_public_keys', d) |
||||
|
d = storage.get('master_private_keys', {}) |
||||
|
d[name] = self.xprv |
||||
|
storage.put('master_private_keys', d) |
||||
|
|
||||
|
def add_master_private_key(self, xprv, password): |
||||
|
self.xprv = pw_encode(xprv, password) |
||||
|
|
||||
|
def get_master_private_key(self, password): |
||||
|
return pw_decode(self.xprv, password) |
||||
|
|
||||
|
def check_password(self, password): |
||||
|
xprv = pw_decode(self.xprv, password) |
||||
|
if deserialize_xkey(xprv)[3] != deserialize_xkey(self.xpub)[3]: |
||||
|
raise InvalidPassword() |
||||
|
|
||||
|
def update_password(self, old_password, new_password): |
||||
|
if old_password is not None: |
||||
|
self.check_password(old_password) |
||||
|
if new_password == '': |
||||
|
new_password = None |
||||
|
if self.has_seed(): |
||||
|
decoded = self.get_seed(old_password) |
||||
|
self.seed = pw_encode( decoded, new_password) |
||||
|
if self.xprv is not None: |
||||
|
b = pw_decode(self.xprv, old_password) |
||||
|
self.xprv = pw_encode(b, new_password) |
||||
|
self.use_encryption = (new_password is not None) |
||||
|
|
||||
|
def is_watching_only(self): |
||||
|
return self.xprv is None |
||||
|
|
||||
|
def get_keypairs_for_sig(self, tx, password): |
||||
|
keypairs = {} |
||||
|
for txin in tx.inputs(): |
||||
|
num_sig = txin.get('num_sig') |
||||
|
if num_sig is None: |
||||
|
continue |
||||
|
x_signatures = txin['signatures'] |
||||
|
signatures = filter(None, x_signatures) |
||||
|
if len(signatures) == num_sig: |
||||
|
# input is complete |
||||
|
continue |
||||
|
for k, x_pubkey in enumerate(txin['x_pubkeys']): |
||||
|
if x_signatures[k] is not None: |
||||
|
# this pubkey already signed |
||||
|
continue |
||||
|
derivation = txin['derivation'] |
||||
|
sec = self.get_private_key(derivation, password) |
||||
|
if sec: |
||||
|
keypairs[x_pubkey] = sec |
||||
|
|
||||
|
return keypairs |
||||
|
|
||||
|
def sign_transaction(self, tx, password): |
||||
|
# Raise if password is not correct. |
||||
|
self.check_password(password) |
||||
|
# Add private keys |
||||
|
keypairs = self.get_keypairs_for_sig(tx, password) |
||||
|
# Sign |
||||
|
if keypairs: |
||||
|
tx.sign(keypairs) |
||||
|
|
||||
|
def derive_xkeys(self, root, derivation, password): |
||||
|
x = self.master_private_keys[root] |
||||
|
root_xprv = pw_decode(x, password) |
||||
|
xprv, xpub = bip32_private_derivation(root_xprv, root, derivation) |
||||
|
return xpub, xprv |
||||
|
|
||||
|
def get_mnemonic(self, password): |
||||
|
return self.get_seed(password) |
||||
|
|
||||
|
def mnemonic_to_seed(self, seed, password): |
||||
|
return Mnemonic.mnemonic_to_seed(seed, password) |
||||
|
|
||||
|
@classmethod |
||||
|
def make_seed(self, lang=None): |
||||
|
return Mnemonic(lang).make_seed() |
||||
|
|
||||
|
@classmethod |
||||
|
def address_derivation(self, account_id, change, address_index): |
||||
|
account_derivation = self.account_derivation(account_id) |
||||
|
return "%s/%d/%d" % (account_derivation, change, address_index) |
||||
|
|
||||
|
def address_id(self, address): |
||||
|
acc_id, (change, address_index) = self.get_address_index(address) |
||||
|
return self.address_derivation(acc_id, change, address_index) |
||||
|
|
||||
|
def add_seed_and_xprv(self, seed, password, passphrase=''): |
||||
|
xprv, xpub = bip32_root(self.mnemonic_to_seed(seed, passphrase)) |
||||
|
xprv, xpub = bip32_private_derivation(xprv, "m/", self.root_derivation) |
||||
|
self.add_seed(seed, password) |
||||
|
self.add_master_private_key(xprv, password) |
||||
|
self.add_master_public_key(xpub) |
||||
|
|
||||
|
def add_xprv(self, xprv, password): |
||||
|
xpub = bitcoin.xpub_from_xprv(xprv) |
||||
|
self.add_master_private_key(xprv, password) |
||||
|
self.add_master_public_key(xpub) |
||||
|
|
||||
|
def can_sign(self, xpub): |
||||
|
return xpub == self.xpub and self.xprv is not None |
||||
|
|
||||
|
def get_private_key(self, sequence, password): |
||||
|
xprv = self.get_master_private_key(password) |
||||
|
_, _, _, c, k = deserialize_xkey(xprv) |
||||
|
pk = bip32_private_key(sequence, k, c) |
||||
|
return pk |
||||
|
|
||||
|
|
||||
|
class Old_KeyStore(Deterministic_KeyStore): |
||||
|
|
||||
|
def __init__(self): |
||||
|
Deterministic_KeyStore.__init__(self) |
||||
|
self.mpk = None |
||||
|
|
||||
|
def load(self, storage, name): |
||||
|
Deterministic_KeyStore.load(self, storage, name) |
||||
|
self.mpk = storage.get('master_public_key').decode('hex') |
||||
|
|
||||
|
def save(self, storage, name): |
||||
|
Deterministic_KeyStore.save(self, storage, name) |
||||
|
storage.put('wallet_type', 'old') |
||||
|
storage.put('master_public_key', self.mpk.encode('hex')) |
||||
|
|
||||
|
def add_seed(self, seed, password): |
||||
|
Deterministic_KeyStore.add_seed(self, seed, password) |
||||
|
self.mpk = self.mpk_from_seed(self.get_seed(password)) |
||||
|
|
||||
|
def add_master_public_key(self, mpk): |
||||
|
self.mpk = mpk.decode('hex') |
||||
|
|
||||
|
def format_seed(self, seed): |
||||
|
import old_mnemonic |
||||
|
# see if seed was entered as hex |
||||
|
seed = seed.strip() |
||||
|
if seed: |
||||
|
try: |
||||
|
seed.decode('hex') |
||||
|
return OLD_SEED_VERSION, str(seed) |
||||
|
except Exception: |
||||
|
pass |
||||
|
words = seed.split() |
||||
|
seed = old_mnemonic.mn_decode(words) |
||||
|
if not seed: |
||||
|
raise Exception("Invalid seed") |
||||
|
return OLD_SEED_VERSION, seed |
||||
|
|
||||
|
def get_mnemonic(self, password): |
||||
|
import old_mnemonic |
||||
|
s = self.get_seed(password) |
||||
|
return ' '.join(old_mnemonic.mn_encode(s)) |
||||
|
|
||||
|
@classmethod |
||||
|
def mpk_from_seed(klass, seed): |
||||
|
secexp = klass.stretch_key(seed) |
||||
|
master_private_key = ecdsa.SigningKey.from_secret_exponent(secexp, curve = SECP256k1) |
||||
|
master_public_key = master_private_key.get_verifying_key().to_string() |
||||
|
return master_public_key |
||||
|
|
||||
|
@classmethod |
||||
|
def stretch_key(self, seed): |
||||
|
x = seed |
||||
|
for i in range(100000): |
||||
|
x = hashlib.sha256(x + seed).digest() |
||||
|
return string_to_number(x) |
||||
|
|
||||
|
@classmethod |
||||
|
def get_sequence(self, mpk, for_change, n): |
||||
|
return string_to_number(Hash("%d:%d:"%(n, for_change) + mpk)) |
||||
|
|
||||
|
def get_address(self, for_change, n): |
||||
|
pubkey = self.get_pubkey(for_change, n) |
||||
|
address = public_key_to_bc_address(pubkey.decode('hex')) |
||||
|
return address |
||||
|
|
||||
|
@classmethod |
||||
|
def get_pubkey_from_mpk(self, mpk, for_change, n): |
||||
|
z = self.get_sequence(mpk, for_change, n) |
||||
|
master_public_key = ecdsa.VerifyingKey.from_string(mpk, curve = SECP256k1) |
||||
|
pubkey_point = master_public_key.pubkey.point + z*SECP256k1.generator |
||||
|
public_key2 = ecdsa.VerifyingKey.from_public_point(pubkey_point, curve = SECP256k1) |
||||
|
return '04' + public_key2.to_string().encode('hex') |
||||
|
|
||||
|
def derive_pubkey(self, for_change, n): |
||||
|
return self.get_pubkey_from_mpk(self.mpk, for_change, n) |
||||
|
|
||||
|
def get_private_key_from_stretched_exponent(self, for_change, n, secexp): |
||||
|
order = generator_secp256k1.order() |
||||
|
secexp = (secexp + self.get_sequence(self.mpk, for_change, n)) % order |
||||
|
pk = number_to_string(secexp, generator_secp256k1.order()) |
||||
|
compressed = False |
||||
|
return SecretToASecret(pk, compressed) |
||||
|
|
||||
|
def get_private_key(self, sequence, password): |
||||
|
seed = self.get_seed(password) |
||||
|
self.check_seed(seed) |
||||
|
for_change, n = sequence |
||||
|
secexp = self.stretch_key(seed) |
||||
|
pk = self.get_private_key_from_stretched_exponent(for_change, n, secexp) |
||||
|
return pk |
||||
|
|
||||
|
def check_seed(self, seed): |
||||
|
secexp = self.stretch_key(seed) |
||||
|
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 ) |
||||
|
master_public_key = master_private_key.get_verifying_key().to_string() |
||||
|
if master_public_key != self.mpk: |
||||
|
print_error('invalid password (mpk)', self.mpk.encode('hex'), master_public_key.encode('hex')) |
||||
|
raise InvalidPassword() |
||||
|
|
||||
|
def check_password(self, password): |
||||
|
seed = self.get_seed(password) |
||||
|
self.check_seed(seed) |
||||
|
|
||||
|
def get_master_public_key(self): |
||||
|
return self.mpk.encode('hex') |
||||
|
|
||||
|
def get_xpubkeys(self, for_change, n): |
||||
|
s = ''.join(map(lambda x: bitcoin.int_to_hex(x,2), (for_change, n))) |
||||
|
mpk = self.mpk.encode('hex') |
||||
|
x_pubkey = 'fe' + mpk + s |
||||
|
return [ x_pubkey ] |
||||
|
|
||||
|
@classmethod |
||||
|
def parse_xpubkey(self, x_pubkey): |
||||
|
assert is_extended_pubkey(x_pubkey) |
||||
|
pk = x_pubkey[2:] |
||||
|
mpk = pk[0:128] |
||||
|
dd = pk[128:] |
||||
|
s = [] |
||||
|
while dd: |
||||
|
n = int(bitcoin.rev_hex(dd[0:4]), 16) |
||||
|
dd = dd[4:] |
||||
|
s.append(n) |
||||
|
assert len(s) == 2 |
||||
|
return mpk, s |
||||
|
|
||||
|
def update_password(self, old_password, new_password): |
||||
|
if old_password is not None: |
||||
|
self.check_password(old_password) |
||||
|
if new_password == '': |
||||
|
new_password = None |
||||
|
if self.has_seed(): |
||||
|
decoded = self.get_seed(old_password) |
||||
|
self.seed = pw_encode(decoded, new_password) |
||||
|
self.use_encryption = (new_password is not None) |
||||
|
|
||||
|
|
||||
|
class Hardware_KeyStore(KeyStore, Xpub): |
||||
|
# Derived classes must set: |
||||
|
# - device |
||||
|
# - DEVICE_IDS |
||||
|
# - wallet_type |
||||
|
|
||||
|
#restore_wallet_class = BIP32_RD_Wallet |
||||
|
max_change_outputs = 1 |
||||
|
|
||||
|
def __init__(self): |
||||
|
Xpub.__init__(self) |
||||
|
KeyStore.__init__(self) |
||||
|
# Errors and other user interaction is done through the wallet's |
||||
|
# handler. The handler is per-window and preserved across |
||||
|
# device reconnects |
||||
|
self.handler = None |
||||
|
|
||||
|
def is_deterministic(self): |
||||
|
return True |
||||
|
|
||||
|
def load(self, storage, name): |
||||
|
self.xpub = storage.get('master_public_keys', {}).get(name) |
||||
|
|
||||
|
def save(self, storage, name): |
||||
|
d = storage.get('master_public_keys', {}) |
||||
|
d[name] = self.xpub |
||||
|
storage.put('master_public_keys', d) |
||||
|
|
||||
|
def unpaired(self): |
||||
|
'''A device paired with the wallet was diconnected. This can be |
||||
|
called in any thread context.''' |
||||
|
self.print_error("unpaired") |
||||
|
|
||||
|
def paired(self): |
||||
|
'''A device paired with the wallet was (re-)connected. This can be |
||||
|
called in any thread context.''' |
||||
|
self.print_error("paired") |
||||
|
|
||||
|
def can_export(self): |
||||
|
return False |
||||
|
|
||||
|
def is_watching_only(self): |
||||
|
'''The wallet is not watching-only; the user will be prompted for |
||||
|
pin and passphrase as appropriate when needed.''' |
||||
|
assert not self.has_seed() |
||||
|
return False |
||||
|
|
||||
|
def can_change_password(self): |
||||
|
return False |
||||
|
|
||||
|
def derive_xkeys(self, root, derivation, password): |
||||
|
if self.master_public_keys.get(self.root_name): |
||||
|
return BIP44_wallet.derive_xkeys(self, root, derivation, password) |
||||
|
# When creating a wallet we need to ask the device for the |
||||
|
# master public key |
||||
|
xpub = self.get_public_key(derivation) |
||||
|
return xpub, None |
||||
|
|
||||
|
|
||||
|
class BIP44_KeyStore(BIP32_KeyStore): |
||||
|
root_derivation = "m/44'/0'/0'" |
||||
|
|
||||
|
def normalize_passphrase(self, passphrase): |
||||
|
return normalize('NFKD', unicode(passphrase or '')) |
||||
|
|
||||
|
def is_valid_seed(self, seed): |
||||
|
return True |
||||
|
|
||||
|
def mnemonic_to_seed(self, mnemonic, passphrase): |
||||
|
# See BIP39 |
||||
|
import pbkdf2, hashlib, hmac |
||||
|
PBKDF2_ROUNDS = 2048 |
||||
|
mnemonic = normalize('NFKD', ' '.join(mnemonic.split())) |
||||
|
passphrase = self.normalize_passphrase(passphrase) |
||||
|
return pbkdf2.PBKDF2(mnemonic, 'mnemonic' + passphrase, |
||||
|
iterations = PBKDF2_ROUNDS, macmodule = hmac, |
||||
|
digestmodule = hashlib.sha512).read(64) |
||||
|
|
||||
|
def on_restore_wallet(self, wizard): |
||||
|
#assert isinstance(keystore, self.keystore_class) |
||||
|
#msg = _("Enter the seed for your %s wallet:" % self.device) |
||||
|
#title=_('Restore hardware wallet'), |
||||
|
f = lambda seed: wizard.run('on_restore_seed', seed) |
||||
|
wizard.restore_seed_dialog(run_next=f, is_valid=self.is_valid_seed) |
||||
|
|
||||
|
def on_restore_seed(self, wizard, seed): |
||||
|
f = lambda passphrase: wizard.run('on_restore_passphrase', seed, passphrase) |
||||
|
self.device = '' |
||||
|
wizard.request_passphrase(self.device, run_next=f) |
||||
|
|
||||
|
def on_restore_passphrase(self, wizard, seed, passphrase): |
||||
|
f = lambda pw: wizard.run('on_restore_password', seed, passphrase, pw) |
||||
|
wizard.request_password(run_next=f) |
||||
|
|
||||
|
def on_restore_password(self, wizard, seed, passphrase, password): |
||||
|
self.add_seed_and_xprv(seed, password, passphrase) |
||||
|
self.save(wizard.storage, 'x/') |
||||
|
|
||||
|
|
||||
|
|
||||
|
keystores = [] |
||||
|
|
||||
|
def load_keystore(storage, name): |
||||
|
w = storage.get('wallet_type') |
||||
|
t = storage.get('key_type', 'seed') |
||||
|
seed_version = storage.get_seed_version() |
||||
|
if seed_version == OLD_SEED_VERSION or w == 'old': |
||||
|
k = Old_KeyStore() |
||||
|
elif t == 'imported': |
||||
|
k = Imported_KeyStore() |
||||
|
elif name and name not in [ 'x/', 'x1/' ]: |
||||
|
k = BIP32_KeyStore() |
||||
|
elif t == 'seed': |
||||
|
k = BIP32_KeyStore() |
||||
|
elif t == 'hardware': |
||||
|
hw_type = storage.get('hardware_type') |
||||
|
for cat, _type, constructor in keystores: |
||||
|
if cat == 'hardware' and _type == hw_type: |
||||
|
k = constructor() |
||||
|
break |
||||
|
else: |
||||
|
raise BaseException('unknown hardware type') |
||||
|
elif t == 'hw_seed': |
||||
|
k = BIP44_KeyStore() |
||||
|
else: |
||||
|
raise BaseException('unknown wallet type', t) |
||||
|
k.load(storage, name) |
||||
|
return k |
||||
|
|
||||
|
|
||||
|
def register_keystore(category, type, constructor): |
||||
|
keystores.append((category, type, constructor)) |
||||
|
|
||||
|
|
||||
|
def is_old_mpk(mpk): |
||||
|
try: |
||||
|
int(mpk, 16) |
||||
|
except: |
||||
|
return False |
||||
|
return len(mpk) == 128 |
||||
|
|
||||
|
def is_xpub(text): |
||||
|
if text[0:4] != 'xpub': |
||||
|
return False |
||||
|
try: |
||||
|
deserialize_xkey(text) |
||||
|
return True |
||||
|
except: |
||||
|
return False |
||||
|
|
||||
|
def is_xprv(text): |
||||
|
if text[0:4] != 'xprv': |
||||
|
return False |
||||
|
try: |
||||
|
deserialize_xkey(text) |
||||
|
return True |
||||
|
except: |
||||
|
return False |
||||
|
|
||||
|
def is_address_list(text): |
||||
|
parts = text.split() |
||||
|
return bool(parts) and all(bitcoin.is_address(x) for x in parts) |
||||
|
|
||||
|
def is_private_key_list(text): |
||||
|
parts = text.split() |
||||
|
return bool(parts) and all(bitcoin.is_private_key(x) for x in parts) |
||||
|
|
||||
|
is_seed = lambda x: is_old_seed(x) or is_new_seed(x) |
||||
|
is_mpk = lambda x: is_old_mpk(x) or is_xpub(x) |
||||
|
is_private = lambda x: is_seed(x) or is_xprv(x) or is_private_key_list(x) |
||||
|
is_any_key = lambda x: is_old_mpk(x) or is_xprv(x) or is_xpub(x) or is_address_list(x) or is_private_key_list(x) |
||||
|
is_private_key = lambda x: is_xprv(x) or is_private_key_list(x) |
||||
|
is_bip32_key = lambda x: is_xprv(x) or is_xpub(x) |
||||
|
|
||||
|
|
||||
|
def from_seed(seed, password): |
||||
|
if is_old_seed(seed): |
||||
|
keystore = Old_KeyStore() |
||||
|
keystore.add_seed(seed, password) |
||||
|
elif is_new_seed(seed): |
||||
|
keystore = BIP32_KeyStore() |
||||
|
keystore.add_seed_and_xprv(seed, password) |
||||
|
return keystore |
||||
|
|
||||
|
def from_private_key_list(text, password): |
||||
|
keystore = Imported_KeyStore() |
||||
|
for x in text.split(): |
||||
|
keystore.import_key(x, None) |
||||
|
keystore.update_password(None, password) |
||||
|
return keystore |
||||
|
|
||||
|
def from_old_mpk(mpk): |
||||
|
keystore = Old_KeyStore() |
||||
|
keystore.add_master_public_key(mpk) |
||||
|
return keystore |
||||
|
|
||||
|
def from_xpub(xpub): |
||||
|
keystore = BIP32_KeyStore() |
||||
|
keystore.add_master_public_key(xpub) |
||||
|
return keystore |
||||
|
|
||||
|
def from_xprv(xprv, password): |
||||
|
xpub = bitcoin.xpub_from_xprv(xprv) |
||||
|
keystore = BIP32_KeyStore() |
||||
|
keystore.add_master_private_key(xprv, password) |
||||
|
keystore.add_master_public_key(xpub) |
||||
|
return keystore |
||||
|
|
||||
|
def xprv_from_seed(seed, password): |
||||
|
# do not store the seed, only the master xprv |
||||
|
xprv, xpub = bip32_root(Mnemonic.mnemonic_to_seed(seed, '')) |
||||
|
#xprv, xpub = bip32_private_derivation(xprv, "m/", self.root_derivation) |
||||
|
return from_xprv(xprv, password) |
||||
|
|
||||
|
def xpub_from_seed(seed): |
||||
|
# store only master xpub |
||||
|
xprv, xpub = bip32_root(Mnemonic.mnemonic_to_seed(seed,'')) |
||||
|
#xprv, xpub = bip32_private_derivation(xprv, "m/", self.root_derivation) |
||||
|
return from_xpub(xpub) |
||||
|
|
||||
|
def from_text(text, password): |
||||
|
if is_xprv(text): |
||||
|
k = from_xprv(text, password) |
||||
|
elif is_old_mpk(text): |
||||
|
k = from_old_mpk(text) |
||||
|
elif is_xpub(text): |
||||
|
k = from_xpub(text) |
||||
|
elif is_private_key_list(text): |
||||
|
k = from_private_key_list(text, password) |
||||
|
elif is_seed(text): |
||||
|
k = from_seed(text, password) |
||||
|
else: |
||||
|
raise BaseException('Invalid seedphrase or key') |
||||
|
return k |
||||
@ -0,0 +1,253 @@ |
|||||
|
#!/usr/bin/env python |
||||
|
# |
||||
|
# Electrum - lightweight Bitcoin client |
||||
|
# Copyright (C) 2015 Thomas Voegtlin |
||||
|
# |
||||
|
# Permission is hereby granted, free of charge, to any person |
||||
|
# obtaining a copy of this software and associated documentation files |
||||
|
# (the "Software"), to deal in the Software without restriction, |
||||
|
# including without limitation the rights to use, copy, modify, merge, |
||||
|
# publish, distribute, sublicense, and/or sell copies of the Software, |
||||
|
# and to permit persons to whom the Software is furnished to do so, |
||||
|
# subject to the following conditions: |
||||
|
# |
||||
|
# The above copyright notice and this permission notice shall be |
||||
|
# included in all copies or substantial portions of the Software. |
||||
|
# |
||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
||||
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||||
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
||||
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
||||
|
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
||||
|
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
||||
|
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
|
# SOFTWARE. |
||||
|
|
||||
|
import os |
||||
|
import ast |
||||
|
import threading |
||||
|
import random |
||||
|
import time |
||||
|
import json |
||||
|
import copy |
||||
|
import re |
||||
|
import stat |
||||
|
|
||||
|
from i18n import _ |
||||
|
from util import NotEnoughFunds, PrintError, profiler |
||||
|
from plugins import run_hook, plugin_loaders |
||||
|
|
||||
|
class WalletStorage(PrintError): |
||||
|
|
||||
|
def __init__(self, path): |
||||
|
self.lock = threading.RLock() |
||||
|
self.data = {} |
||||
|
self.path = path |
||||
|
self.file_exists = False |
||||
|
self.modified = False |
||||
|
self.print_error("wallet path", self.path) |
||||
|
if self.path: |
||||
|
self.read(self.path) |
||||
|
|
||||
|
# check here if I need to load a plugin |
||||
|
t = self.get('wallet_type') |
||||
|
l = plugin_loaders.get(t) |
||||
|
if l: l() |
||||
|
|
||||
|
|
||||
|
def read(self, path): |
||||
|
"""Read the contents of the wallet file.""" |
||||
|
try: |
||||
|
with open(self.path, "r") as f: |
||||
|
data = f.read() |
||||
|
except IOError: |
||||
|
return |
||||
|
if not data: |
||||
|
return |
||||
|
try: |
||||
|
self.data = json.loads(data) |
||||
|
except: |
||||
|
try: |
||||
|
d = ast.literal_eval(data) #parse raw data from reading wallet file |
||||
|
labels = d.get('labels', {}) |
||||
|
except Exception as e: |
||||
|
raise IOError("Cannot read wallet file '%s'" % self.path) |
||||
|
self.data = {} |
||||
|
# In old versions of Electrum labels were latin1 encoded, this fixes breakage. |
||||
|
for i, label in labels.items(): |
||||
|
try: |
||||
|
unicode(label) |
||||
|
except UnicodeDecodeError: |
||||
|
d['labels'][i] = unicode(label.decode('latin1')) |
||||
|
for key, value in d.items(): |
||||
|
try: |
||||
|
json.dumps(key) |
||||
|
json.dumps(value) |
||||
|
except: |
||||
|
self.print_error('Failed to convert label to json format', key) |
||||
|
continue |
||||
|
self.data[key] = value |
||||
|
self.file_exists = True |
||||
|
|
||||
|
def get(self, key, default=None): |
||||
|
with self.lock: |
||||
|
v = self.data.get(key) |
||||
|
if v is None: |
||||
|
v = default |
||||
|
else: |
||||
|
v = copy.deepcopy(v) |
||||
|
return v |
||||
|
|
||||
|
def put(self, key, value): |
||||
|
try: |
||||
|
json.dumps(key) |
||||
|
json.dumps(value) |
||||
|
except: |
||||
|
self.print_error("json error: cannot save", key) |
||||
|
return |
||||
|
with self.lock: |
||||
|
if value is not None: |
||||
|
if self.data.get(key) != value: |
||||
|
self.modified = True |
||||
|
self.data[key] = copy.deepcopy(value) |
||||
|
elif key in self.data: |
||||
|
self.modified = True |
||||
|
self.data.pop(key) |
||||
|
|
||||
|
def write(self): |
||||
|
with self.lock: |
||||
|
self._write() |
||||
|
self.file_exists = True |
||||
|
|
||||
|
def _write(self): |
||||
|
if threading.currentThread().isDaemon(): |
||||
|
self.print_error('warning: daemon thread cannot write wallet') |
||||
|
return |
||||
|
if not self.modified: |
||||
|
return |
||||
|
s = json.dumps(self.data, indent=4, sort_keys=True) |
||||
|
temp_path = "%s.tmp.%s" % (self.path, os.getpid()) |
||||
|
with open(temp_path, "w") as f: |
||||
|
f.write(s) |
||||
|
f.flush() |
||||
|
os.fsync(f.fileno()) |
||||
|
|
||||
|
mode = os.stat(self.path).st_mode if os.path.exists(self.path) else stat.S_IREAD | stat.S_IWRITE |
||||
|
# perform atomic write on POSIX systems |
||||
|
try: |
||||
|
os.rename(temp_path, self.path) |
||||
|
except: |
||||
|
os.remove(self.path) |
||||
|
os.rename(temp_path, self.path) |
||||
|
os.chmod(self.path, mode) |
||||
|
self.print_error("saved", self.path) |
||||
|
self.modified = False |
||||
|
|
||||
|
def requires_split(self): |
||||
|
d = self.get('accounts', {}) |
||||
|
return len(d) > 1 |
||||
|
|
||||
|
def split_accounts(storage): |
||||
|
result = [] |
||||
|
# backward compatibility with old wallets |
||||
|
d = storage.get('accounts', {}) |
||||
|
if len(d) < 2: |
||||
|
return |
||||
|
wallet_type = storage.get('wallet_type') |
||||
|
if wallet_type == 'old': |
||||
|
assert len(d) == 2 |
||||
|
storage1 = WalletStorage(storage.path + '.deterministic') |
||||
|
storage1.data = copy.deepcopy(storage.data) |
||||
|
storage1.put('accounts', {'0': d['0']}) |
||||
|
storage1.write() |
||||
|
storage2 = WalletStorage(storage.path + '.imported') |
||||
|
storage2.data = copy.deepcopy(storage.data) |
||||
|
storage2.put('accounts', {'/x': d['/x']}) |
||||
|
storage2.put('seed', None) |
||||
|
storage2.put('seed_version', None) |
||||
|
storage2.put('master_public_key', None) |
||||
|
storage2.put('wallet_type', 'imported') |
||||
|
storage2.write() |
||||
|
storage2.upgrade() |
||||
|
result = [storage1.path, storage2.path] |
||||
|
elif wallet_type in ['bip44', 'trezor']: |
||||
|
mpk = storage.get('master_public_keys') |
||||
|
for k in d.keys(): |
||||
|
i = int(k) |
||||
|
x = d[k] |
||||
|
if x.get("pending"): |
||||
|
continue |
||||
|
xpub = mpk["x/%d'"%i] |
||||
|
new_path = storage.path + '.' + k |
||||
|
storage2 = WalletStorage(new_path) |
||||
|
storage2.data = copy.deepcopy(storage.data) |
||||
|
storage2.put('wallet_type', 'standard') |
||||
|
if wallet_type in ['trezor', 'keepkey']: |
||||
|
storage2.put('key_type', 'hardware') |
||||
|
storage2.put('hardware_type', wallet_type) |
||||
|
storage2.put('accounts', {'0': x}) |
||||
|
# need to save derivation and xpub too |
||||
|
storage2.put('master_public_keys', {'x/': xpub}) |
||||
|
storage2.put('account_id', k) |
||||
|
storage2.write() |
||||
|
result.append(new_path) |
||||
|
else: |
||||
|
raise BaseException("This wallet has multiple accounts and must be split") |
||||
|
return result |
||||
|
|
||||
|
def requires_upgrade(storage): |
||||
|
# '/x' is the internal ID for imported accounts |
||||
|
return bool(storage.get('accounts', {}).get('/x', {}).get('imported',{})) |
||||
|
|
||||
|
def upgrade(storage): |
||||
|
d = storage.get('accounts', {}).get('/x', {}).get('imported',{}) |
||||
|
addresses = [] |
||||
|
keypairs = {} |
||||
|
for addr, v in d.items(): |
||||
|
pubkey, privkey = v |
||||
|
if privkey: |
||||
|
keypairs[pubkey] = privkey |
||||
|
else: |
||||
|
addresses.append(addr) |
||||
|
if addresses and keypairs: |
||||
|
raise BaseException('mixed addresses and privkeys') |
||||
|
elif addresses: |
||||
|
storage.put('addresses', addresses) |
||||
|
storage.put('accounts', None) |
||||
|
elif keypairs: |
||||
|
storage.put('wallet_type', 'standard') |
||||
|
storage.put('key_type', 'imported') |
||||
|
storage.put('keypairs', keypairs) |
||||
|
storage.put('accounts', None) |
||||
|
else: |
||||
|
raise BaseException('no addresses or privkeys') |
||||
|
storage.write() |
||||
|
|
||||
|
def get_action(self): |
||||
|
action = run_hook('get_action', self) |
||||
|
if action: |
||||
|
return action |
||||
|
if not self.file_exists: |
||||
|
return 'new' |
||||
|
|
||||
|
def get_seed_version(self): |
||||
|
from version import OLD_SEED_VERSION, NEW_SEED_VERSION |
||||
|
seed_version = self.get('seed_version') |
||||
|
if not seed_version: |
||||
|
seed_version = OLD_SEED_VERSION if len(self.get('master_public_key','')) == 128 else NEW_SEED_VERSION |
||||
|
if seed_version not in [OLD_SEED_VERSION, NEW_SEED_VERSION]: |
||||
|
msg = "Your wallet has an unsupported seed version." |
||||
|
msg += '\n\nWallet file: %s' % os.path.abspath(self.path) |
||||
|
if seed_version in [5, 7, 8, 9, 10]: |
||||
|
msg += "\n\nTo open this wallet, try 'git checkout seed_v%d'"%seed_version |
||||
|
if seed_version == 6: |
||||
|
# version 1.9.8 created v6 wallets when an incorrect seed was entered in the restore dialog |
||||
|
msg += '\n\nThis file was created because of a bug in version 1.9.8.' |
||||
|
if self.get('master_public_keys') is None and self.get('master_private_keys') is None and self.get('imported_keys') is None: |
||||
|
# pbkdf2 was not included with the binaries, and wallet creation aborted. |
||||
|
msg += "\nIt does not contain any keys, and can safely be removed." |
||||
|
else: |
||||
|
# creation was complete if electrum was run from source |
||||
|
msg += "\nPlease open this file with Electrum 1.9.8, and move your coins to a new wallet." |
||||
|
raise BaseException(msg) |
||||
|
return seed_version |
||||
File diff suppressed because it is too large
@ -1,2 +1 @@ |
|||||
from hw_wallet import BIP44_HW_Wallet |
|
||||
from plugin import HW_PluginBase |
from plugin import HW_PluginBase |
||||
|
|||||
@ -1,95 +0,0 @@ |
|||||
#!/usr/bin/env python2 |
|
||||
# -*- mode: python -*- |
|
||||
# |
|
||||
# Electrum - lightweight Bitcoin client |
|
||||
# Copyright (C) 2016 The Electrum developers |
|
||||
# |
|
||||
# Permission is hereby granted, free of charge, to any person |
|
||||
# obtaining a copy of this software and associated documentation files |
|
||||
# (the "Software"), to deal in the Software without restriction, |
|
||||
# including without limitation the rights to use, copy, modify, merge, |
|
||||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|
||||
# and to permit persons to whom the Software is furnished to do so, |
|
||||
# subject to the following conditions: |
|
||||
# |
|
||||
# The above copyright notice and this permission notice shall be |
|
||||
# included in all copies or substantial portions of the Software. |
|
||||
# |
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
||||
# SOFTWARE. |
|
||||
|
|
||||
from struct import pack |
|
||||
|
|
||||
from electrum.wallet import BIP44_Wallet |
|
||||
|
|
||||
class BIP44_HW_Wallet(BIP44_Wallet): |
|
||||
'''A BIP44 hardware wallet base class.''' |
|
||||
# Derived classes must set: |
|
||||
# - device |
|
||||
# - DEVICE_IDS |
|
||||
# - wallet_type |
|
||||
|
|
||||
restore_wallet_class = BIP44_Wallet |
|
||||
max_change_outputs = 1 |
|
||||
|
|
||||
def __init__(self, storage): |
|
||||
BIP44_Wallet.__init__(self, storage) |
|
||||
# Errors and other user interaction is done through the wallet's |
|
||||
# handler. The handler is per-window and preserved across |
|
||||
# device reconnects |
|
||||
self.handler = None |
|
||||
|
|
||||
def unpaired(self): |
|
||||
'''A device paired with the wallet was diconnected. This can be |
|
||||
called in any thread context.''' |
|
||||
self.print_error("unpaired") |
|
||||
|
|
||||
def paired(self): |
|
||||
'''A device paired with the wallet was (re-)connected. This can be |
|
||||
called in any thread context.''' |
|
||||
self.print_error("paired") |
|
||||
|
|
||||
def get_action(self): |
|
||||
pass |
|
||||
|
|
||||
def can_create_accounts(self): |
|
||||
return True |
|
||||
|
|
||||
def can_export(self): |
|
||||
return False |
|
||||
|
|
||||
def is_watching_only(self): |
|
||||
'''The wallet is not watching-only; the user will be prompted for |
|
||||
pin and passphrase as appropriate when needed.''' |
|
||||
assert not self.has_seed() |
|
||||
return False |
|
||||
|
|
||||
def can_change_password(self): |
|
||||
return False |
|
||||
|
|
||||
def get_client(self, force_pair=True): |
|
||||
return self.plugin.get_client(self, force_pair) |
|
||||
|
|
||||
def first_address(self): |
|
||||
'''Used to check a hardware wallet matches a software wallet''' |
|
||||
account = self.accounts.get('0') |
|
||||
derivation = self.address_derivation('0', 0, 0) |
|
||||
return (account.first_address()[0] if account else None, derivation) |
|
||||
|
|
||||
def derive_xkeys(self, root, derivation, password): |
|
||||
if self.master_public_keys.get(self.root_name): |
|
||||
return BIP44_wallet.derive_xkeys(self, root, derivation, password) |
|
||||
|
|
||||
# When creating a wallet we need to ask the device for the |
|
||||
# master public key |
|
||||
xpub = self.get_public_key(derivation) |
|
||||
return xpub, None |
|
||||
|
|
||||
def i4b(self, x): |
|
||||
return pack('>I', x) |
|
||||
Loading…
Reference in new issue