def create_client(self, device, handler):
from trezorlib.transport.hid import HidTransport
try:
self.print_error("connecting to device at", device.path)
if device.path is None:
devices = HidTransport.enumerate()
if not devices:
raise Exception("No OCTO device found") from None
d = devices[0]
transport = Device(d.get_path(), -1, d.get_path(), 'OCTO', 0)
else:
# if not device.path.startswith('hid'):
# raise Exception("Unknown path prefix '%s'" % device.path)
transport = HidTransport.find_by_path(device.path)
except BaseException as e:
self.print_error("cannot connect at", device.path, str(e))
return None
if not transport:
self.print_error("cannot connect at", device.path)
return
print("connected to device at {}".format(device.path), flush=True)
client = self.client_class(transport, handler, self)
# Try a ping for device sanity
try:
client.ping('t')
except BaseException as e:
self.print_error("ping failed", str(e))
return None
return client
def enumerate(self):
devices = self.transport_handler.enumerate_devices()
return [Device(path=d.get_path(),
interface_number=-1,
id_=d.get_path(),
product_key='Safe-T mini',
usage_page=0,
transport_ui_string=d.get_path())
for d in devices]
def detect_simulator(self):
# if there is a simulator running on this machine,
# return details about it so it's offered as a pairing choice
fn = CKCC_SIMULATOR_PATH
if os.path.exists(fn):
return [Device(fn, -1, fn, (COINKITE_VID, CKCC_SIMULATED_PID), 0)]
return []
def enumerate(self):
devices = trezorlib.transport.enumerate_devices()
return [Device(path=d.get_path(),
interface_number=-1,
id_=d.get_path(),
product_key=TREZOR_PRODUCT_KEY,
usage_page=0,
transport_ui_string=d.get_path())
for d in devices]
def enumerate(self):
from keepkeylib.transport_webusb import WebUsbTransport
results = []
for dev in WebUsbTransport.enumerate():
path = self._dev_to_str(dev)
results.append(Device(path=path,
interface_number=-1,
id_=path,
product_key=(dev.getVendorID(), dev.getProductID()),
usage_page=0,
transport_ui_string=f"webusb:{path}"))
return results
def enumerate_serial(self):
# Jade is not really an HID device, it shows as a serial/com port device.
# Scan com ports looking for the relevant vid and pid, and use 'path' to
# hold the path to the serial port device, eg. /dev/ttyUSB0
devices = []
for devinfo in list_ports.comports():
device_product_key = (devinfo.vid, devinfo.pid)
if device_product_key in self.DEVICE_IDS:
device = Device(path=devinfo.device,
interface_number=-1,
id_=devinfo.serial_number,
product_key=device_product_key,
usage_page=-1,
transport_ui_string=devinfo.device)
devices.append(device)
# Maybe look for Jade Qemu simulator if the vars are set (experimental)
if self.SIMULATOR_PATH is not None and self.SIMULATOR_TEST_SEED is not None:
try:
# If we can connect to a simulator and poke a seed in, add that too
client = Jade_Client(self.SIMULATOR_PATH, plugin=self)
device = Device(path=self.SIMULATOR_PATH,
interface_number=-1,
id_='Jade Qemu Simulator',
product_key=self.DEVICE_IDS[0],
usage_page=-1,
transport_ui_string='simulator')
if client.jade.set_seed(self.SIMULATOR_TEST_SEED):
devices.append(device)
client.close()
except Exception as e:
# If we get any sort of error do not add the simulator
_logger.debug(
"Failed to connect to Jade simulator at {}".format(
self.SIMULATOR_PATH))
_logger.debug(e)
return devices
def detect_simulator(self):
# if there is a simulator running on this machine,
# return details about it so it's offered as a pairing choice
fn = CKCC_SIMULATOR_PATH
if os.path.exists(fn):
return [Device(path=fn,
interface_number=-1,
id_=fn,
product_key=(COINKITE_VID, CKCC_SIMULATED_PID),
usage_page=0,
transport_ui_string='simulator')]
return []
def create_device_from_hid_enumeration(self, d: dict, *, product_key) -> 'Device':
# Older versions of hid don't provide interface_number
interface_number = d.get('interface_number', -1)
usage_page = d['usage_page']
id_ = d['serial_number']
if len(id_) == 0:
id_ = str(d['path'])
id_ += str(interface_number) + str(usage_page)
device = Device(path=d['path'],
interface_number=interface_number,
id_=id_,
product_key=product_key,
usage_page=usage_page,
transport_ui_string='hid')
return device
def enumerate(self):
# If there is a bridge, prefer that.
# On Windows, the bridge runs as Admin (and Electrum usually does not),
# so the bridge has better chances of finding devices. see #5420
# This also avoids duplicate entries.
if self.is_bridge_available():
devices = BridgeTransport.enumerate()
else:
devices = trezorlib.transport.enumerate_devices()
return [Device(path=d.get_path(),
interface_number=-1,
id_=d.get_path(),
product_key=TREZOR_PRODUCT_KEY,
usage_page=0,
transport_ui_string=d.get_path())
for d in devices]
def create_device_from_hid_enumeration(self, d: dict, *,
product_key) -> Optional['Device']:
# note: id_ needs to be unique between simultaneously connected devices,
# and ideally unchanged while a device is connected.
# Older versions of hid don't provide interface_number
interface_number = d.get('interface_number', -1)
usage_page = d['usage_page']
# id_=str(d['path']) in itself might be sufficient, but this had to be touched
# a number of times already, so let's just go for the overkill approach:
id_ = f"{d['path']},{d['serial_number']},{interface_number},{usage_page}"
device = Device(path=d['path'],
interface_number=interface_number,
id_=id_,
product_key=product_key,
usage_page=usage_page,
transport_ui_string='hid')
return device
def enumerate(self):
devices = self.transport_handler.enumerate_devices()
return [
Device(d.get_path(), -1, d.get_path(), 'TREZOR', 0)
for d in devices
]
def enumerate(self):
from trezorlib.transport.hid import HidTransport
devices = HidTransport.enumerate()
return [
Device(d.get_path(), -1, d.get_path(), 'OCTO', 0) for d in devices
]
