def get_transport(transport_string, path, **kwargs):
if transport_string == 'usb':
from keepkeylib.transport_hid import HidTransport
if path == '':
try:
path = list_usb()[0][0]
except IndexError:
raise Exception("No KeepKey found on USB")
for d in HidTransport.enumerate():
# Two-tuple of (normal_interface, debug_interface)
if path in d:
return HidTransport(d, **kwargs)
raise Exception("Device not found")
if transport_string == 'serial':
from keepkeylib.transport_serial import SerialTransport
return SerialTransport(path, **kwargs)
if transport_string == 'pipe':
from keepkeylib.transport_pipe import PipeTransport
return PipeTransport(path, is_device=False, **kwargs)
if transport_string == 'socket':
from keepkeylib.transport_socket import SocketTransportClient
return SocketTransportClient(path, **kwargs)
if transport_string == 'fake':
from keepkeylib.transport_fake import FakeTransport
return FakeTransport(path, **kwargs)
raise NotImplementedError("Unknown transport")
def main():
# List all connected KeepKeys on USB
devices = HidTransport.enumerate()
# Check whether we found any
if len(devices) == 0:
print('No KeepKey found')
return
# Use first connected device
transport = HidTransport(devices[0])
# Creates object for manipulating KeepKey
client = KeepKeyClient(transport)
# Print out KeepKey's features and settings
print(client.features)
# Get the first address of first BIP44 account
# (should be the same address as shown in KeepKey wallet Chrome extension)
bip32_path = client.expand_path("44'/0'/0'/0/0")
address = client.get_address('morningstar', bip32_path)
print('morningstar address:', address)
client.close()
def find_device():
"""Returns first WebUSB or HID transport."""
for d in WebUsbTransport.enumerate():
return WebUsbTransport(d)
for d in HidTransport.enumerate():
return HidTransport(d)
def main():
# List all connected KeepKeys on USB
devices = HidTransport.enumerate()
# Check whether we found any
if len(devices) == 0:
print('No KeepKey found')
return
# Use first connected device
transport = HidTransport(devices[0])
# Creates object for manipulating KeepKey
client = KeepKeyClient(transport)
# Print out KeepKey's features and settings
print(client.features)
# Get the first address of first BIP44 account
# (should be the same address as shown in KeepKey wallet Chrome extension)
mpath = "44'/0'/0'/0"
bip32_path = client.expand_path(mpath)
print bip32.serialize(client.get_public_node(bip32_path).node, 0x043587CF)
for i in range(11):
child_path = '%s%s' % ("44'/0'/0'/0/", str(i))
address = client.get_address('tDash', client.expand_path(child_path))
print 'tDASH address:', child_path, address
client.close()
def get_transport():
from keepkeylib.transport_hid import HidTransport
count = len(HidTransport.enumerate())
if not count:
logging.warning('Number of Keepkey devices: 0')
for d in HidTransport.enumerate():
transport = HidTransport(d)
return transport
def __init__(self, path, password=''):
super(KeepkeyClient, self).__init__(path, password)
devices = HidTransport.enumerate()
transport = HidTransport((path.encode(), None))
self.client = KeepKey(transport)
# if it wasn't able to find a client, throw an error
if not self.client:
raise IOError("no Device")
self.password = password
os.environ['PASSPHRASE'] = password
def __init__(self, device, path):
super(KeepKeyClient, self).__init__(device)
device.close()
devices = HidTransport.enumerate()
self.client = None
for d in devices:
if d[0] == path:
transport = HidTransport(d)
self.client = KeepKey(transport)
break
# if it wasn't able to find a client, throw an error
if not self.client:
raise IOError("no Device")
def _get_transport(self, device):
self.logger.debug("Trying to connect over USB...")
if device.path.startswith('web_usb'):
for d in self._enumerate_web_usb():
if self._web_usb_path(d) == device.path:
from keepkeylib.transport_webusb import WebUsbTransport
return WebUsbTransport(d)
else:
for d in self._enumerate_hid():
if str(d[0]) == device.path:
from keepkeylib.transport_hid import HidTransport
return HidTransport(d)
raise RuntimeError(f'device {device} not found')
def get_client() -> Optional[MyKeepkeyClient]:
from keepkeylib.transport_hid import HidTransport
count = len(HidTransport.enumerate())
if not count:
logging.warning('Number of Keepkey devices: 0')
for d in HidTransport.enumerate():
transport = HidTransport(d)
client = MyKeepkeyClient(transport, ask_for_pin_callback, ask_for_pass_callback)
if not device_id or client.features.device_id == device_id:
return client
else:
client.clear_session()
client.close()
return None
def connect_keepkey(ask_for_pin_fun, ask_for_pass_fun):
try:
from keepkeylib.transport_hid import HidTransport
transport = None
for d in HidTransport.enumerate():
transport = HidTransport(d)
break
if transport:
client = MyKeepkeyClient(transport, ask_for_pin_fun, ask_for_pass_fun)
return client
else:
return None
except Exception as e:
raise
def get_client(self):
if not KEEPKEY:
give_error('please install github.com/keepkey/python-keepkey')
if not self.client or self.client.bad:
d = HidTransport.enumerate()
if not d:
give_error('Could not connect to your KeepKey. Please verify the cable is connected and that no other app is using it.')
self.transport = HidTransport(d[0])
self.client = QtGuiKeepKeyClient(self.transport)
self.client.handler = self.handler
self.client.set_tx_api(self)
self.client.bad = False
if not self.atleast_version(1, 0, 0):
self.client = None
give_error('Outdated KeepKey firmware. Please update the firmware from https://www.keepkey.com')
return self.client
enumerateStatus = True
signal.alarm(0)
except:
print("Enumerate failed, continuing next pass")
time.sleep(0.5)
if enumerateCount == 3:
break
enumerateCount += 1
continue
if enumerateStatus is False:
print("Enumerate hard failed, power cycling")
continue
print("Fetching path...")
for d in HidTransport.enumerate():
if path in d:
transport = HidTransport(d)
break
print("Transport locked, continuing...")
phy.set_capture_size(1025)
client = KeepKeyClient(transport)
print("KeepKeyClient OK, arming glitcher...")
scope.arm()
phy.arm()
print("Arm OK")
if oneshot:
input("Hit enter to fire glitch event...")
try:
signal.alarm(10)
data = client.ping("HelloHelloHelloHelloHello")
print(data)
if data != "HelloHelloHelloHelloHello":
def check_hw_wallet():
printdbg('checking hw wallet')
#client = None
client = None
signing = False
if TYPE_HW_WALLET.lower().startswith("keepkey"):
from keepkeylib.client import KeepKeyClient
from keepkeylib.transport_hid import HidTransport
import keepkeylib.ckd_public as bip32
try:
devices = HidTransport.enumerate()
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if len(devices) == 0:
print('===> No HW Wallet found')
signing = False
else:
try:
print('===> keepkey HW Wallet found')
transport = HidTransport(devices[0])
client = KeepKeyClient(transport)
signing = True
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
elif TYPE_HW_WALLET.lower().startswith("trezor"):
from trezorlib.client import TrezorClient
from trezorlib.transport_hid import HidTransport
import trezorlib.ckd_public as bip32
try:
devices = HidTransport.enumerate()
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if len(devices) == 0:
print('===> No HW Wallet found')
signing = False
else:
try:
print('===> trezor HW Wallet found')
transport = HidTransport(devices[0])
client = TrezorClient(transport)
signing = True
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
elif TYPE_HW_WALLET.lower().startswith("ledgernanos"):
#from btchip.btchip import *
#from btchip.btchipUtils import *
try:
devices = getDongle(False)
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if not devices:
print('===> No HW Wallet found')
signing = False
else:
try:
print('===> Ledger nano s HW Wallet found')
client = btchip(devices)
signing = True
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if client is not None:
if TYPE_HW_WALLET.lower().startswith("ledgernanos"):
pass
else:
try:
wallet_supported_coins = list_coins(client)
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if coin_name not in wallet_supported_coins:
err_msg = 'only following coins supported by wallet\n\t' + \
str(wallet_supported_coins)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
else:
err_msg = "Can't run florijncoinmnb without hw wallet"
print_err_exit(get_caller_name(), get_function_name(), err_msg)
if TYPE_HW_WALLET.lower().startswith("ledgernanos"):
mpath = get_mpath()
return client, signing, mpath
else:
try:
mpath = get_mpath()
bip32_path = client.expand_path(mpath)
xpub = bip32.serialize(
client.get_public_node(bip32_path).node,
(0x0488B21E if MAINNET else 0x043587CF))
except AssertionError as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
except Exception as e:
err_msg = str(e.args)
print_err_exit(get_caller_name(), get_function_name(), err_msg)
except KeyboardInterrupt:
print_err_exit(get_caller_name(), get_function_name(),
"KeyboardInterrupt")
printdbg('check_hw_wallet : signing : %s' % signing)
printdbg('check_hw_wallet : xpub[:7] : %s' % xpub[:7])
printdbg('check_hw_wallet : xpub[-7:] : %s' % xpub[-7:])
printdbg('check_hw_wallet : mpath : %s' % mpath)
return client, signing, bip32, mpath, xpub
from keepkeylib.client import KeepKeyClient
from keepkeylib.transport_hid import HidTransport
import keepkeylib.types_pb2 as proto_types
from keepkeylib import tx_api
from keepkeylib.tx_api import TXAPIDashTestnet
tx_api.rpcuser = '******'
tx_api.rpcpassword = '******'
devices = HidTransport.enumerate()
if len(devices) == 0:
print('No KeepKey found')
sys.exit()
transport = HidTransport(devices[0])
client = KeepKeyClient(transport)
client.set_tx_api(TXAPIDashTestnet())
inp1 = proto_types.TxInputType(
address_n=[44 | 0x80000000, 165 | 0x80000000, 0 | 0x80000000, 0,
0], # yjJUQ42u8Z86s9LiUmNgvS9dSzhunWbuQR
# amount=500000000
prev_hash=binascii.unhexlify(
'4a1f3f89d95dd162e30399386dd7748c7fa02ec958320f4542923cf3a63fde48'),
prev_index=1,
)
out1 = proto_types.TxOutputType(
address='yV7G6wcfkqfjw3SyykJzYnsL3fqJByqXYG',
amount=500000000 - 10000,
def enumerate_transports():
"""Returns USB HID transports."""
return [HidTransport(p) for p in HidTransport.enumerate()]
def get_device_list(return_clients: bool = True, passphrase_encoding: Optional[str] = 'NFC',
allow_bootloader_mode: bool = False) \
-> Tuple[List[Dict], List[Exception]]:
"""
:return: Tuple[List[Dict <{'client': MyTrezorClient, 'device_id': str, 'desc',: str, 'model': str}>],
List[Exception]]
"""
from keepkeylib.transport_hid import HidTransport
ret_list = []
exceptions: List[Exception] = []
device_ids = []
was_bootloader_mode = False
for d in HidTransport.enumerate():
try:
transport = HidTransport(d)
client = MyKeepkeyClient(transport, ask_for_pin_callback, ask_for_pass_callback, passphrase_encoding)
if client.features.bootloader_mode:
if was_bootloader_mode:
# in bootloader mode the device_id attribute isn't available, so for a given client object
# we are unable to distinguish between being the same device reached with the different
# transport and being another device
# for that reason, to avoid returning duplicate clients for the same device, we don't return
# more than one instance of a device in bootloader mod
client.close()
continue
was_bootloader_mode = True
if (not client.features.bootloader_mode or allow_bootloader_mode) and \
(client.features.device_id not in device_ids or client.features.bootloader_mode):
version = f'{client.features.major_version}.{client.features.minor_version}.' \
f'{client.features.patch_version}'
if client.features.label:
desc = client.features.label
else:
desc = '[UNNAMED]'
desc = f'{desc} (ver: {version}, id: {client.features.device_id})'
c = {
'client': client,
'device_id': client.features.device_id,
'desc': desc,
'model': client.features.model,
'bootloader_mode': client.features.bootloader_mode
}
ret_list.append(c)
device_ids.append(client.features.device_id) # beware: it's empty in bootloader mode
else:
# the same device is already connected using different connection medium
client.close()
except Exception as e:
logging.warning(
f'Cannot create Keepkey client ({d.__class__.__name__}) due to the following error: ' + str(e))
exceptions.append(e)
if not return_clients:
for cli in ret_list:
cli['client'].close()
cli['client'] = None
return ret_list, exceptions
def hid_transport(self, pair):
from keepkeylib.transport_hid import HidTransport
return HidTransport(pair)
def find_device():
"""Returns first USB HID transport."""
return next(HidTransport(p) for p in HidTransport.enumerate())
