keepkey-0.7.3/0000755000076500000240000000000012726077014013404 5ustar darinstaff00000000000000keepkey-0.7.3/keepkey.egg-info/0000755000076500000240000000000012726077014016533 5ustar darinstaff00000000000000keepkey-0.7.3/keepkey.egg-info/dependency_links.txt0000644000076500000240000000000112726077013022600 0ustar darinstaff00000000000000 keepkey-0.7.3/keepkey.egg-info/not-zip-safe0000644000076500000240000000000112726077013020760 0ustar darinstaff00000000000000 keepkey-0.7.3/keepkey.egg-info/PKG-INFO0000644000076500000240000000102612726077013017626 0ustar darinstaff00000000000000Metadata-Version: 1.1 Name: keepkey Version: 0.7.3 Summary: Python library for communicating with KeepKey Hardware Wallet Home-page: https://github.com/keepkey/python-keepkey Author: Bitcoin TREZOR and KeepKey Author-email: support@keepkey.com License: UNKNOWN Description: UNKNOWN Platform: UNKNOWN Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: MacOS :: MacOS X keepkey-0.7.3/keepkey.egg-info/requires.txt0000644000076500000240000000007612726077013021135 0ustar darinstaff00000000000000ecdsa>=0.9 protobuf>=2.6.1 mnemonic>=0.8 hidapi==0.7.99.post15keepkey-0.7.3/keepkey.egg-info/SOURCES.txt0000644000076500000240000000323212726077014020417 0ustar darinstaff00000000000000MANIFEST.in README.rst keepkeyctl setup.py keepkey.egg-info/PKG-INFO keepkey.egg-info/SOURCES.txt keepkey.egg-info/dependency_links.txt keepkey.egg-info/not-zip-safe keepkey.egg-info/requires.txt keepkey.egg-info/top_level.txt keepkeylib/__init__.py keepkeylib/ckd_public.py keepkeylib/client.py keepkeylib/debuglink.py keepkeylib/mapping.py keepkeylib/messages_pb2.py keepkeylib/protobuf_json.py keepkeylib/tools.py keepkeylib/transport.py keepkeylib/transport_fake.py keepkeylib/transport_hid.py keepkeylib/transport_pipe.py keepkeylib/transport_serial.py keepkeylib/transport_socket.py keepkeylib/tx_api.py keepkeylib/types_pb2.py keepkeylib/qt/__init__.py keepkeylib/qt/pinmatrix.py tests/common.py tests/config.py tests/run-jenkins.sh tests/run-separate.sh tests/run.sh tests/test_basic.py tests/test_bip32_speed.py tests/test_bootloader.py tests/test_debuglink.py tests/test_ecies.py tests/test_msg_applysettings.py tests/test_msg_changepin.py tests/test_msg_cipherkeyvalue.py tests/test_msg_clearsession.py tests/test_msg_estimatetxsize.py tests/test_msg_getaddress.py tests/test_msg_getaddress_show.py tests/test_msg_getentropy.py tests/test_msg_getpublickey.py tests/test_msg_loaddevice.py tests/test_msg_ping.py tests/test_msg_recoverydevice.py tests/test_msg_recoverydevice_cipher.py tests/test_msg_resetdevice.py tests/test_msg_signidentity.py tests/test_msg_signmessage.py tests/test_msg_signtx.py tests/test_msg_signtx_xfer.py tests/test_msg_simplesigntx.py tests/test_msg_verifymessage.py tests/test_msg_wipedevice.py tests/test_multisig.py tests/test_multisig_change.py tests/test_op_return.py tests/test_protect_call.py tests/test_protection_levels.py tests/test_zerosig.pykeepkey-0.7.3/keepkey.egg-info/top_level.txt0000644000076500000240000000001312726077013021256 0ustar darinstaff00000000000000keepkeylib keepkey-0.7.3/keepkeyctl0000755000076500000240000003673412726074236015512 0ustar darinstaff00000000000000#!/usr/bin/env python from __future__ import print_function import os import binascii import argparse import json import base64 import urllib import tempfile from keepkeylib.client import KeepKeyClient, KeepKeyClientDebug def parse_args(commands): parser = argparse.ArgumentParser(description='Commandline tool for KeepKey devices.') parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='Prints communication to device') parser.add_argument('-t', '--transport', dest='transport', choices=['usb', 'serial', 'pipe', 'socket', 'bridge'], default='usb', help="Transport used for talking with the device") parser.add_argument('-p', '--path', dest='path', default='', help="Path used by the transport (usually serial port)") # parser.add_argument('-dt', '--debuglink-transport', dest='debuglink_transport', choices=['usb', 'serial', 'pipe', 'socket'], default='usb', help="Debuglink transport") # parser.add_argument('-dp', '--debuglink-path', dest='debuglink_path', default='', help="Path used by the transport (usually serial port)") parser.add_argument('-j', '--json', dest='json', action='store_true', help="Prints result as json object") # parser.add_argument('-d', '--debug', dest='debug', action='store_true', help='Enable low-level debugging') cmdparser = parser.add_subparsers(title='Available commands') for cmd in commands._list_commands(): func = object.__getattribute__(commands, cmd) try: arguments = func.arguments except AttributeError: arguments = ((('params',), {'nargs': '*'}),) item = cmdparser.add_parser(cmd, help=func.help) for arg in arguments: item.add_argument(*arg[0], **arg[1]) item.set_defaults(func=func) item.set_defaults(cmd=cmd) return parser.parse_args() 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") class Commands(object): def __init__(self, client): self.client = client @classmethod def _list_commands(cls): return [x for x in dir(cls) if not x.startswith('_')] def list(self, args): # Fake method for advertising 'list' command pass def get_address(self, args): address_n = self.client.expand_path(args.n) return self.client.get_address(args.coin, address_n, args.show_display) def get_entropy(self, args): return binascii.hexlify(self.client.get_entropy(args.size)) def get_features(self, args): return self.client.features def list_coins(self, args): return [coin.coin_name for coin in self.client.features.coins] def ping(self, args): return self.client.ping(args.msg, button_protection=args.button_protection, pin_protection=args.pin_protection, passphrase_protection=args.passphrase_protection) def get_public_node(self, args): address_n = self.client.expand_path(args.n) return self.client.get_public_node(address_n, ecdsa_curve_name=args.curve, show_display=args.show_display) def set_label(self, args): return self.client.apply_settings(label=args.label) def clear_session(self, args): return self.client.clear_session() def change_pin(self, args): return self.client.change_pin(args.remove) def wipe_device(self, args): return self.client.wipe_device() def recovery_device(self, args): return self.client.recovery_device(args.use_trezor_method, args.words, args.passphrase_protection, args.pin_protection, args.label, 'english') def load_device(self, args): if not args.mnemonic and not args.xprv: raise Exception("Please provide mnemonic or xprv") if args.mnemonic: mnemonic = ' '.join(args.mnemonic) return self.client.load_device_by_mnemonic(mnemonic, args.pin, args.passphrase_protection, args.label, 'english', args.skip_checksum) else: return self.client.load_device_by_xprv(args.xprv, args.pin, args.passphrase_protection, args.label, 'english') def reset_device(self, args): return self.client.reset_device(True, args.strength, args.passphrase_protection, args.pin_protection, args.label, 'english') def sign_message(self, args): address_n = self.client.expand_path(args.n) ret = self.client.sign_message(args.coin, address_n, args.message) output = { 'message': args.message, 'address': ret.address, 'signature': base64.b64encode(ret.signature) } return output def verify_message(self, args): signature = base64.b64decode(args.signature) return self.client.verify_message(args.address, signature, args.message) def encrypt_message(self, args): pubkey = binascii.unhexlify(args.pubkey) address_n = self.client.expand_path(args.n) ret = self.client.encrypt_message(pubkey, args.message, args.display_only, args.coin, address_n) output = { 'nonce': binascii.hexlify(ret.nonce), 'message': binascii.hexlify(ret.message), 'hmac': binascii.hexlify(ret.hmac), 'payload': base64.b64encode(ret.nonce + ret.message + ret.hmac), } return output def decrypt_message(self, args): address_n = self.client.expand_path(args.n) payload = base64.b64decode(args.payload) nonce, message, msg_hmac = payload[:33], payload[33:-8], payload[-8:] ret = self.client.decrypt_message(address_n, nonce, message, msg_hmac) return ret def encrypt_keyvalue(self, args): address_n = self.client.expand_path(args.n) ret = self.client.encrypt_keyvalue(address_n, args.key, args.value) return binascii.hexlify(ret) def decrypt_keyvalue(self, args): address_n = self.client.expand_path(args.n) ret = self.client.decrypt_keyvalue(address_n, args.key, args.value.decode("hex")) return ret def firmware_update(self, args): if not args.file and not args.url: raise Exception("Must provide firmware filename or URL") if args.file: fp = open(args.file, 'r') elif args.url: print("Downloading from", args.url) resp = urllib.urlretrieve(args.url) fp = open(resp[0], 'r') urllib.urlcleanup() # We still keep file pointer open if fp.read(8) == '54525a52': print("Converting firmware to binary") fp.seek(0) fp_old = fp fp = tempfile.TemporaryFile() fp.write(binascii.unhexlify(fp_old.read())) fp_old.close() fp.seek(0) if fp.read(4) != 'KPKY': raise Exception("KeepKey firmware header expected") print("Please confirm action on device...") fp.seek(0) return self.client.firmware_update(fp=fp) list.help = 'List connected KeepKey USB devices' ping.help = 'Send ping message' get_address.help = 'Get bitcoin address in base58 encoding' get_entropy.help = 'Get example entropy' get_features.help = 'Retrieve device features and settings' get_public_node.help = 'Get public node of given path' set_label.help = 'Set new wallet label' clear_session.help = 'Clear session (remove cached PIN, passphrase, etc.)' change_pin.help = 'Change new PIN or remove existing' list_coins.help = 'List all supported coin types by the device' wipe_device.help = 'Reset device to factory defaults and remove all private data.' recovery_device.help = 'Start safe recovery workflow' load_device.help = 'Load custom configuration to the device' reset_device.help = 'Perform device setup and generate new seed' sign_message.help = 'Sign message using address of given path' verify_message.help = 'Verify message' encrypt_message.help = 'Encrypt message' decrypt_message.help = 'Decrypt message' encrypt_keyvalue.help = 'Encrypt value by given key and path' decrypt_keyvalue.help = 'Decrypt value by given key and path' firmware_update.help = 'Upload new firmware to device (must be in bootloader mode)' get_address.arguments = ( (('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}), (('-n', '-address'), {'type': str}), (('-d', '--show-display'), {'action': 'store_true', 'default': False}), ) get_entropy.arguments = ( (('size',), {'type': int}), ) get_features.arguments = () list_coins.arguments = () ping.arguments = ( (('msg',), {'type': str}), (('-b', '--button-protection'), {'action': 'store_true', 'default': False}), (('-p', '--pin-protection'), {'action': 'store_true', 'default': False}), (('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}), ) set_label.arguments = ( (('-l', '--label',), {'type': str, 'default': ''}), # (('-c', '--clear'), {'action': 'store_true', 'default': False}) ) change_pin.arguments = ( (('-r', '--remove'), {'action': 'store_true', 'default': False}), ) wipe_device.arguments = () recovery_device.arguments = ( (('-t', '--use-trezor-method'), {'action': 'store_true', 'default': False}), (('-w', '--words'), {'type': int}), (('-p', '--pin-protection'), {'action': 'store_true', 'default': False}), (('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}), (('-l', '--label'), {'type': str, 'default': ''}), ) load_device.arguments = ( (('-m', '--mnemonic'), {'type': str, 'nargs': '+'}), (('-x', '--xprv'), {'type': str}), (('-p', '--pin'), {'type': str, 'default': ''}), (('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}), (('-l', '--label'), {'type': str, 'default': ''}), (('-s', '--skip-checksum'), {'action': 'store_true', 'default': False}), ) reset_device.arguments = ( (('-t', '--strength'), {'type': int, 'choices': [128, 192, 256], 'default': 256}), (('-p', '--pin-protection'), {'action': 'store_true', 'default': False}), (('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}), (('-l', '--label'), {'type': str, 'default': ''}), ) sign_message.arguments = ( (('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}), (('-n', '-address'), {'type': str}), (('message',), {'type': str}), ) encrypt_message.arguments = ( (('pubkey',), {'type': str}), (('message',), {'type': str}), (('-d', '--display-only'), {'action': 'store_true', 'default': False}), (('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}), (('-n', '-address'), {'type': str}), ) decrypt_message.arguments = ( (('-n', '-address'), {'type': str}), (('payload',), {'type': str}), ) verify_message.arguments = ( (('address',), {'type': str}), (('signature',), {'type': str}), (('message',), {'type': str}), ) encrypt_keyvalue.arguments = ( (('-n', '-address'), {'type': str}), (('key',), {'type': str}), (('value',), {'type': str}), ) decrypt_keyvalue.arguments = ( (('-n', '-address'), {'type': str}), (('key',), {'type': str}), (('value',), {'type': str}), ) get_public_node.arguments = ( (('-n', '-address'), {'type': str}), (('-e', '--curve'), {'type': str}), (('-d', '--show-display'), {'action': 'store_true', 'default': False}), ) firmware_update.arguments = ( (('-f', '--file'), {'type': str}), (('-u', '--url'), {'type': str}), ) def list_usb(): from keepkeylib.transport_hid import HidTransport return HidTransport.enumerate() ''' class PinMatrixThread(threading.Thread): # Hacked PinMatrixWidget into command line tool :-). def __init__(self, input_text, message): super(PinMatrixThread, self).__init__() self.input_text = input_text self.message = message self.pin_value = '' def run(self): from keepkeylib.pinmatrix import PinMatrixWidget import sys from PyQt4.Qt import QApplication, QWidget, QVBoxLayout from PyQt4.QtGui import QPushButton, QLabel from PyQt4.QtCore import QObject, SIGNAL a = QApplication(sys.argv) pass matrix = PinMatrixWidget() def clicked(): self.pin_value = str(matrix.get_value()) a.closeAllWindows() ok = QPushButton('OK') QObject.connect(ok, SIGNAL('clicked()'), clicked) vbox = QVBoxLayout() vbox.addWidget(QLabel(self.input_text + self.message)) vbox.addWidget(matrix) vbox.addWidget(ok) w = QWidget() w.setLayout(vbox) w.move(100, 100) w.show() a.exec_() def qt_pin_func(input_text, message=None): # This is a hack to display Qt window in non-qt application. # Qt window just asks for PIN and closes itself, which trigger join(). if False: # os.getenv('DISPLAY'): # Let's hope that system is configured properly and this won't crash t = PinMatrixThread(input_text, message) t.start() t.join() return t.pin_value else: # Most likely no X is running, # let's fallback to default pin_func implementation return pin_func(input_text, message) ''' def main(): args = parse_args(Commands) if args.cmd == 'list': devices = list_usb() if args.json: print(json.dumps(devices)) else: for dev in devices: if dev[1] != None: print("%s - debuglink enabled" % dev[0]) else: print(dev[0]) return transport = get_transport(args.transport, args.path) if args.verbose: client = KeepKeyClientDebug(transport) else: client = KeepKeyClient(transport) cmds = Commands(client) res = args.func(cmds, args) if args.json: print(json.dumps(res, sort_keys=True, indent=4)) else: print(res) if __name__ == '__main__': main() keepkey-0.7.3/keepkeylib/0000755000076500000240000000000012726077014015530 5ustar darinstaff00000000000000keepkey-0.7.3/keepkeylib/__init__.py0000644000076500000240000000000012717427115017630 0ustar darinstaff00000000000000keepkey-0.7.3/keepkeylib/ckd_public.py0000644000076500000240000000717012726074236020211 0ustar darinstaff00000000000000import struct import hmac import hashlib import ecdsa from ecdsa.util import string_to_number, number_to_string from ecdsa.curves import SECP256k1 from ecdsa.ellipticcurve import Point, INFINITY from . import tools from . import types_pb2 as proto_types PRIME_DERIVATION_FLAG = 0x80000000 def point_to_pubkey(point): order = SECP256k1.order x_str = number_to_string(point.x(), order) y_str = number_to_string(point.y(), order) vk = x_str + y_str return chr((ord(vk[63]) & 1) + 2) + vk[0:32] # To compressed key def sec_to_public_pair(pubkey): """Convert a public key in sec binary format to a public pair.""" x = string_to_number(pubkey[1:33]) sec0 = pubkey[:1] if sec0 not in (b'\2', b'\3'): raise Exception("Compressed pubkey expected") def public_pair_for_x(generator, x, is_even): curve = generator.curve() p = curve.p() alpha = (pow(x, 3, p) + curve.a() * x + curve.b()) % p beta = ecdsa.numbertheory.square_root_mod_prime(alpha, p) if is_even == bool(beta & 1): return (x, p - beta) return (x, beta) return public_pair_for_x(ecdsa.ecdsa.generator_secp256k1, x, is_even=(sec0 == b'\2')) def is_prime(n): return (bool)(n & PRIME_DERIVATION_FLAG) def fingerprint(pubkey): return string_to_number(tools.hash_160(pubkey)[:4]) def get_address(public_node, address_type): return tools.public_key_to_bc_address(public_node.public_key, address_type) def public_ckd(public_node, n): if not isinstance(n, list): raise Exception('Parameter must be a list') node = proto_types.HDNodeType() node.CopyFrom(public_node) for i in n: node.CopyFrom(get_subnode(node, i)) return node def get_subnode(node, i): # Public Child key derivation (CKD) algorithm of BIP32 i_as_bytes = struct.pack(">L", i) if is_prime(i): raise Exception("Prime derivation not supported") # Public derivation data = node.public_key + i_as_bytes I64 = hmac.HMAC(key=node.chain_code, msg=data, digestmod=hashlib.sha512).digest() I_left_as_exponent = string_to_number(I64[:32]) node_out = proto_types.HDNodeType() node_out.depth = node.depth + 1 node_out.child_num = i node_out.chain_code = I64[32:] node_out.fingerprint = fingerprint(node.public_key) # BIP32 magic converts old public key to new public point x, y = sec_to_public_pair(node.public_key) point = I_left_as_exponent * SECP256k1.generator + \ Point(SECP256k1.curve, x, y, SECP256k1.order) if point == INFINITY: raise Exception("Point cannot be INFINITY") # Convert public point to compressed public key node_out.public_key = point_to_pubkey(point) return node_out def serialize(node, version=0x0488B21E): s = '' s += struct.pack('>I', version) s += struct.pack('>B', node.depth) s += struct.pack('>I', node.fingerprint) s += struct.pack('>I', node.child_num) s += node.chain_code if node.private_key: s += '\x00' + node.private_key else: s += node.public_key s += tools.Hash(s)[:4] return tools.b58encode(s) def deserialize(xpub): data = tools.b58decode(xpub, None) if tools.Hash(data[:-4])[:4] != data[-4:]: raise Exception("Checksum failed") node = proto_types.HDNodeType() node.depth = struct.unpack('>B', data[4:5])[0] node.fingerprint = struct.unpack('>I', data[5:9])[0] node.child_num = struct.unpack('>I', data[9:13])[0] node.chain_code = data[13:45] key = data[45:-4] if key[0] == '\x00': node.private_key = key[1:] else: node.public_key = key return node keepkey-0.7.3/keepkeylib/client.py0000644000076500000240000007725112726074236017377 0ustar darinstaff00000000000000from __future__ import print_function import os import sys import time import binascii import hashlib import unicodedata import json import getpass from mnemonic import Mnemonic from . import tools from . import mapping from . import messages_pb2 as proto from . import types_pb2 as types from .debuglink import DebugLink # try: # from PIL import Image # SCREENSHOT = True # except: # SCREENSHOT = False SCREENSHOT = False DEFAULT_CURVE = 'secp256k1' # monkeypatching: text formatting of protobuf messages tools.monkeypatch_google_protobuf_text_format() def get_buttonrequest_value(code): # Converts integer code to its string representation of ButtonRequestType return [ k for k, v in types.ButtonRequestType.items() if v == code][0] def pprint(msg): msg_class = msg.__class__.__name__ msg_size = msg.ByteSize() """ msg_ser = msg.SerializeToString() msg_id = mapping.get_type(msg) msg_json = json.dumps(protobuf_json.pb2json(msg)) """ if isinstance(msg, proto.FirmwareUpload): return "<%s> (%d bytes):\n" % (msg_class, msg_size) else: return "<%s> (%d bytes):\n%s" % (msg_class, msg_size, msg) def log(msg): sys.stderr.write("%s\n" % msg) sys.stderr.flush() def log_cr(msg): sys.stdout.write('\r%s' % msg) sys.stdout.flush() def log_backspace(times): for _ in range(times): sys.stdout.write('\b') sys.stdout.flush() def format_mnemonic(word_pos, character_pos): return "WORD %d: %s" % (word_pos, character_pos * '*') def getch(): try: import termios except ImportError: # Non-POSIX. Return msvcrt's (Windows') getch. import msvcrt return msvcrt.getch() # POSIX system. Create and return a getch that manipulates the tty. import sys, tty def _getch(): fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(fd) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch return _getch() class CallException(Exception): def __init__(self, code, message): super(CallException, self).__init__() self.args = [code, message] class PinException(CallException): pass class field(object): # Decorator extracts single value from # protobuf object. If the field is not # present, raises an exception. def __init__(self, field): self.field = field def __call__(self, f): def wrapped_f(*args, **kwargs): ret = f(*args, **kwargs) ret.HasField(self.field) return getattr(ret, self.field) return wrapped_f class expect(object): # Decorator checks if the method # returned one of expected protobuf messages # or raises an exception def __init__(self, *expected): self.expected = expected def __call__(self, f): def wrapped_f(*args, **kwargs): ret = f(*args, **kwargs) if not isinstance(ret, self.expected): raise Exception("Got %s, expected %s" % (ret.__class__, self.expected)) return ret return wrapped_f def normalize_nfc(txt): if sys.version_info[0] < 3: if isinstance(txt, unicode): return unicodedata.normalize('NFC', txt).encode('utf-8') if isinstance(txt, str): return unicodedata.normalize('NFC', txt.decode('utf-8')).encode('utf-8') else: if isinstance(txt, bytes): return unicodedata.normalize('NFC', txt.decode('utf-8')).encode('utf-8') if isinstance(txt, str): return unicodedata.normalize('NFC', txt).encode('utf-8') raise Exception('unicode/str or bytes/str expected') class BaseClient(object): # Implements very basic layer of sending raw protobuf # messages to device and getting its response back. def __init__(self, transport, **kwargs): self.transport = transport super(BaseClient, self).__init__() # *args, **kwargs) def cancel(self): self.transport.write(proto.Cancel()) def call_raw(self, msg): try: self.transport.session_begin() self.transport.write(msg) resp = self.transport.read_blocking() finally: self.transport.session_end() return resp def call(self, msg): try: self.transport.session_begin() resp = self.call_raw(msg) handler_name = "callback_%s" % resp.__class__.__name__ handler = getattr(self, handler_name, None) if handler != None: msg = handler(resp) if msg == None: raise Exception("Callback %s must return protobuf message, not None" % handler) resp = self.call(msg) finally: self.transport.session_end() return resp def callback_Failure(self, msg): if msg.code in (types.Failure_PinInvalid, types.Failure_PinCancelled, types.Failure_PinExpected): raise PinException(msg.code, msg.message) raise CallException(msg.code, msg.message) def close(self): self.transport.close() class DebugWireMixin(object): def call_raw(self, msg): log("SENDING " + pprint(msg)) resp = super(DebugWireMixin, self).call_raw(msg) log("RECEIVED " + pprint(resp)) return resp class TextUIMixin(object): # This class demonstrates easy test-based UI # integration between the device and wallet. # You can implement similar functionality # by implementing your own GuiMixin with # graphical widgets for every type of these callbacks. def __init__(self, *args, **kwargs): super(TextUIMixin, self).__init__(*args, **kwargs) self.character_request_first_pass = True def callback_ButtonRequest(self, msg): # log("Sending ButtonAck for %s " % get_buttonrequest_value(msg.code)) return proto.ButtonAck() def callback_PinMatrixRequest(self, msg): if msg.type == 1: desc = 'current PIN' elif msg.type == 2: desc = 'new PIN' elif msg.type == 3: desc = 'new PIN again' else: desc = 'PIN' log("Use the numeric keypad to describe number positions. The layout is:") log(" 7 8 9") log(" 4 5 6") log(" 1 2 3") log("Please enter %s: " % desc) pin = getpass.getpass('') return proto.PinMatrixAck(pin=pin) def callback_PassphraseRequest(self, msg): log("Passphrase required: ") passphrase = getpass.getpass('') log("Confirm your Passphrase: ") if passphrase == getpass.getpass(''): passphrase = normalize_nfc(passphrase) return proto.PassphraseAck(passphrase=passphrase) else: log("Passphrase did not match! ") exit() def callback_WordRequest(self, msg): log("Enter one word of mnemonic: ") try: word = raw_input() except NameError: word = input() # Python 3 return proto.WordAck(word=word) def callback_CharacterRequest(self, msg): if self.character_request_first_pass: self.character_request_first_pass = False log("Use recovery cipher on device to input mnemonic. Words are autocompleted at 3 or 4 characters.") log("(use spacebar to progress to next word after match, use backspace to correct bad character or word entries)") # format mnemonic for console formatted_console = format_mnemonic(msg.word_pos + 1, msg.character_pos) # clear the runway before we display formatted mnemonic log_cr(' ' * 14) log_cr(formatted_console) while True: character = getch().lower() # capture escape if character in ('\x03', '\x04'): return proto.Cancel() character_ascii = ord(character) if character_ascii >= 97 and character_ascii <= 122 \ and msg.character_pos != 4: # capture characters a-z return proto.CharacterAck(character=character) elif character_ascii == 32 and msg.word_pos < 23 \ and msg.character_pos >= 3: # capture spaces return proto.CharacterAck(character=' ') elif character_ascii == 8 or character_ascii == 127 \ and (msg.word_pos > 0 or msg.character_pos > 0): # capture backspaces return proto.CharacterAck(delete=True) elif character_ascii == 13 and msg.word_pos in (11, 17, 23): # capture returns log("") return proto.CharacterAck(done=True) class DebugLinkMixin(object): # This class implements automatic responses # and other functionality for unit tests # for various callbacks, created in order # to automatically pass unit tests. # # This mixing should be used only for purposes # of unit testing, because it will fail to work # without special DebugLink interface provided # by the device. def __init__(self, *args, **kwargs): super(DebugLinkMixin, self).__init__(*args, **kwargs) self.debug = None self.in_with_statement = 0 self.button_wait = 0 self.screenshot_id = 0 # Always press Yes and provide correct pin self.setup_debuglink(True, True) # Do not expect any specific response from device self.expected_responses = None # Use blank passphrase self.set_passphrase('') def close(self): super(DebugLinkMixin, self).close() if self.debug: self.debug.close() def set_debuglink(self, debug_transport): self.debug = DebugLink(debug_transport) def set_buttonwait(self, secs): self.button_wait = secs def __enter__(self): # For usage in with/expected_responses self.in_with_statement += 1 return self def __exit__(self, _type, value, traceback): self.in_with_statement -= 1 if _type != None: # Another exception raised return False # return isinstance(value, TypeError) # Evaluate missed responses in 'with' statement if self.expected_responses != None and len(self.expected_responses): raise Exception("Some of expected responses didn't come from device: %s" % \ [ pprint(x) for x in self.expected_responses ]) # Cleanup self.expected_responses = None return False def set_expected_responses(self, expected): if not self.in_with_statement: raise Exception("Must be called inside 'with' statement") self.expected_responses = expected def setup_debuglink(self, button, pin_correct): self.button = button # True -> YES button, False -> NO button self.pin_correct = pin_correct def set_passphrase(self, passphrase): self.passphrase = normalize_nfc(passphrase) def set_mnemonic(self, mnemonic): self.mnemonic = unicode(str(bytearray(Mnemonic.normalize_string(mnemonic), 'utf-8')), 'utf-8').split(' ') def call_raw(self, msg): if SCREENSHOT and self.debug: layout = self.debug.read_layout() im = Image.new("RGB", (128, 64)) pix = im.load() for x in range(128): for y in range(64): rx, ry = 127 - x, 63 - y if (ord(layout[rx + (ry / 8) * 128]) & (1 << (ry % 8))) > 0: pix[x, y] = (255, 255, 255) im.save('scr%05d.png' % self.screenshot_id) self.screenshot_id += 1 resp = super(DebugLinkMixin, self).call_raw(msg) self._check_request(resp) return resp def _check_request(self, msg): if self.expected_responses != None: try: expected = self.expected_responses.pop(0) except IndexError: raise CallException(types.Failure_Other, "Got %s, but no message has been expected" % pprint(msg)) if msg.__class__ != expected.__class__: raise CallException(types.Failure_Other, "Expected %s, got %s" % (pprint(expected), pprint(msg))) fields = expected.ListFields() # only filled (including extensions) for field, value in fields: if not msg.HasField(field.name) or getattr(msg, field.name) != value: raise CallException(types.Failure_Other, "Expected %s, got %s" % (pprint(expected), pprint(msg))) def callback_ButtonRequest(self, msg): log("ButtonRequest code: " + get_buttonrequest_value(msg.code)) log("Pressing button " + str(self.button)) if self.button_wait: log("Waiting %d seconds " % self.button_wait) time.sleep(self.button_wait) self.debug.press_button(self.button) return proto.ButtonAck() def callback_PinMatrixRequest(self, msg): if self.pin_correct: pin = self.debug.read_pin_encoded() else: pin = '444222' return proto.PinMatrixAck(pin=pin) def callback_PassphraseRequest(self, msg): log("Provided passphrase: '%s'" % self.passphrase) return proto.PassphraseAck(passphrase=self.passphrase) def callback_WordRequest(self, msg): (word, pos) = self.debug.read_recovery_word() if word != '': return proto.WordAck(word=word) if pos != 0: return proto.WordAck(word=self.mnemonic[pos - 1]) raise Exception("Unexpected call") class ProtocolMixin(object): PRIME_DERIVATION_FLAG = 0x80000000 VENDORS = ('keepkey.com',) def __init__(self, *args, **kwargs): super(ProtocolMixin, self).__init__(*args, **kwargs) self.init_device() self.tx_api = None def set_tx_api(self, tx_api): self.tx_api = tx_api def init_device(self): self.features = expect(proto.Features)(self.call)(proto.Initialize()) if str(self.features.vendor) not in self.VENDORS: raise Exception("Unsupported device") def _get_local_entropy(self): return os.urandom(32) def _convert_prime(self, n): # Convert minus signs to uint32 with flag return [ int(abs(x) | self.PRIME_DERIVATION_FLAG) if x < 0 else x for x in n ] @staticmethod def expand_path(n): # Convert string of bip32 path to list of uint32 integers with prime flags # 0/-1/1' -> [0, 0x80000001, 0x80000001] if not n: return [] n = n.split('/') path = [] for x in n: prime = False if x.endswith("'"): x = x.replace('\'', '') prime = True if x.startswith('-'): prime = True x = abs(int(x)) if prime: x |= ProtocolMixin.PRIME_DERIVATION_FLAG path.append(x) return path @expect(proto.PublicKey) def get_public_node(self, n, ecdsa_curve_name=DEFAULT_CURVE, show_display=False): n = self._convert_prime(n) if not ecdsa_curve_name: ecdsa_curve_name=DEFAULT_CURVE return self.call(proto.GetPublicKey(address_n=n, ecdsa_curve_name=ecdsa_curve_name, show_display=show_display)) @field('address') @expect(proto.Address) def get_address(self, coin_name, n, show_display=False, multisig=None): n = self._convert_prime(n) if multisig: return self.call(proto.GetAddress(address_n=n, coin_name=coin_name, show_display=show_display, multisig=multisig)) else: return self.call(proto.GetAddress(address_n=n, coin_name=coin_name, show_display=show_display)) @field('entropy') @expect(proto.Entropy) def get_entropy(self, size): return self.call(proto.GetEntropy(size=size)) @field('message') @expect(proto.Success) def ping(self, msg, button_protection=False, pin_protection=False, passphrase_protection=False): msg = proto.Ping(message=msg, button_protection=button_protection, pin_protection=pin_protection, passphrase_protection=passphrase_protection) return self.call(msg) def get_device_id(self): return self.features.device_id @field('message') @expect(proto.Success) def apply_settings(self, label=None, language=None, use_passphrase=None, homescreen=None): settings = proto.ApplySettings() if label != None: settings.label = label if language: settings.language = language if use_passphrase != None: settings.use_passphrase = use_passphrase out = self.call(settings) self.init_device() # Reload Features return out @field('message') @expect(proto.Success) def clear_session(self): return self.call(proto.ClearSession()) @field('message') @expect(proto.Success) def change_pin(self, remove=False): ret = self.call(proto.ChangePin(remove=remove)) self.init_device() # Re-read features return ret @expect(proto.MessageSignature) def sign_message(self, coin_name, n, message): n = self._convert_prime(n) # Convert message to UTF8 NFC (seems to be a bitcoin-qt standard) message = normalize_nfc(message) return self.call(proto.SignMessage(coin_name=coin_name, address_n=n, message=message)) @expect(proto.SignedIdentity) def sign_identity(self, identity, challenge_hidden, challenge_visual, ecdsa_curve_name=DEFAULT_CURVE): return self.call(proto.SignIdentity(identity=identity, challenge_hidden=challenge_hidden, challenge_visual=challenge_visual, ecdsa_curve_name=ecdsa_curve_name)) def verify_message(self, address, signature, message): # Convert message to UTF8 NFC (seems to be a bitcoin-qt standard) message = normalize_nfc(message) try: if address: resp = self.call(proto.VerifyMessage(address=address, signature=signature, message=message)) else: resp = self.call(proto.VerifyMessage(signature=signature, message=message)) except CallException as e: resp = e if isinstance(resp, proto.Success): return True return False @expect(proto.EncryptedMessage) def encrypt_message(self, pubkey, message, display_only, coin_name, n): if coin_name and n: n = self._convert_prime(n) return self.call(proto.EncryptMessage(pubkey=pubkey, message=message, display_only=display_only, coin_name=coin_name, address_n=n)) else: return self.call(proto.EncryptMessage(pubkey=pubkey, message=message, display_only=display_only)) @expect(proto.DecryptedMessage) def decrypt_message(self, n, nonce, message, msg_hmac): n = self._convert_prime(n) return self.call(proto.DecryptMessage(address_n=n, nonce=nonce, message=message, hmac=msg_hmac)) @field('value') @expect(proto.CipheredKeyValue) def encrypt_keyvalue(self, n, key, value, ask_on_encrypt=True, ask_on_decrypt=True, iv=None): n = self._convert_prime(n) return self.call(proto.CipherKeyValue(address_n=n, key=key, value=value, encrypt=True, ask_on_encrypt=ask_on_encrypt, ask_on_decrypt=ask_on_decrypt, iv=iv if iv is not None else '')) @field('value') @expect(proto.CipheredKeyValue) def decrypt_keyvalue(self, n, key, value, ask_on_encrypt=True, ask_on_decrypt=True, iv=None): n = self._convert_prime(n) return self.call(proto.CipherKeyValue(address_n=n, key=key, value=value, encrypt=False, ask_on_encrypt=ask_on_encrypt, ask_on_decrypt=ask_on_decrypt, iv=iv if iv is not None else '')) @field('tx_size') @expect(proto.TxSize) def estimate_tx_size(self, coin_name, inputs, outputs): msg = proto.EstimateTxSize() msg.coin_name = coin_name msg.inputs_count = len(inputs) msg.outputs_count = len(outputs) return self.call(msg) def _prepare_simple_sign_tx(self, coin_name, inputs, outputs): msg = proto.SimpleSignTx() msg.coin_name = coin_name msg.inputs.extend(inputs) msg.outputs.extend(outputs) known_hashes = [] for inp in inputs: if inp.prev_hash in known_hashes: continue tx = msg.transactions.add() if self.tx_api: tx.CopyFrom(self.tx_api.get_tx(binascii.hexlify(inp.prev_hash))) else: raise Exception('TX_API not defined') known_hashes.append(inp.prev_hash) return msg def simple_sign_tx(self, coin_name, inputs, outputs): msg = self._prepare_simple_sign_tx(coin_name, inputs, outputs) return self.call(msg).serialized.serialized_tx def _prepare_sign_tx(self, coin_name, inputs, outputs): tx = types.TransactionType() tx.inputs.extend(inputs) tx.outputs.extend(outputs) txes = {} txes[''] = tx known_hashes = [] for inp in inputs: if inp.prev_hash in known_hashes: continue if self.tx_api: txes[inp.prev_hash] = self.tx_api.get_tx(binascii.hexlify(inp.prev_hash)) else: raise Exception('TX_API not defined') known_hashes.append(inp.prev_hash) return txes def sign_tx(self, coin_name, inputs, outputs, debug_processor=None): start = time.time() txes = self._prepare_sign_tx(coin_name, inputs, outputs) try: self.transport.session_begin() # Prepare and send initial message tx = proto.SignTx() tx.inputs_count = len(inputs) tx.outputs_count = len(outputs) tx.coin_name = coin_name res = self.call(tx) # Prepare structure for signatures signatures = [None] * len(inputs) serialized_tx = '' counter = 0 while True: counter += 1 if isinstance(res, proto.Failure): raise CallException("Signing failed") if not isinstance(res, proto.TxRequest): raise CallException("Unexpected message") # If there's some part of signed transaction, let's add it if res.HasField('serialized') and res.serialized.HasField('serialized_tx'): log("RECEIVED PART OF SERIALIZED TX (%d BYTES)" % len(res.serialized.serialized_tx)) serialized_tx += res.serialized.serialized_tx if res.HasField('serialized') and res.serialized.HasField('signature_index'): if signatures[res.serialized.signature_index] != None: raise Exception("Signature for index %d already filled" % res.serialized.signature_index) signatures[res.serialized.signature_index] = res.serialized.signature if res.request_type == types.TXFINISHED: # Device didn't ask for more information, finish workflow break # Device asked for one more information, let's process it. current_tx = txes[res.details.tx_hash] if res.request_type == types.TXMETA: msg = types.TransactionType() msg.version = current_tx.version msg.lock_time = current_tx.lock_time msg.inputs_cnt = len(current_tx.inputs) if res.details.tx_hash: msg.outputs_cnt = len(current_tx.bin_outputs) else: msg.outputs_cnt = len(current_tx.outputs) res = self.call(proto.TxAck(tx=msg)) continue elif res.request_type == types.TXINPUT: msg = types.TransactionType() msg.inputs.extend([current_tx.inputs[res.details.request_index], ]) res = self.call(proto.TxAck(tx=msg)) continue elif res.request_type == types.TXOUTPUT: msg = types.TransactionType() if res.details.tx_hash: msg.bin_outputs.extend([current_tx.bin_outputs[res.details.request_index], ]) else: msg.outputs.extend([current_tx.outputs[res.details.request_index], ]) if debug_processor != None: # If debug_processor function is provided, # pass thru it the request and prepared response. # This is useful for unit tests, see test_msg_signtx msg = debug_processor(res, msg) res = self.call(proto.TxAck(tx=msg)) continue finally: self.transport.session_end() if None in signatures: raise Exception("Some signatures are missing!") log("SIGNED IN %.03f SECONDS, CALLED %d MESSAGES, %d BYTES" % \ (time.time() - start, counter, len(serialized_tx))) return (signatures, serialized_tx) @field('message') @expect(proto.Success) def wipe_device(self): ret = self.call(proto.WipeDevice()) self.init_device() return ret @field('message') @expect(proto.Success) def recovery_device(self, use_trezor_method, word_count, passphrase_protection, pin_protection, label, language): if self.features.initialized: raise Exception("Device is initialized already. Call wipe_device() and try again.") if not use_trezor_method: word_count = 0 elif word_count not in (12, 18, 24): raise Exception("Invalid word count. Use 12/18/24") res = self.call(proto.RecoveryDevice(word_count=int(word_count), passphrase_protection=bool(passphrase_protection), pin_protection=bool(pin_protection), label=label, language=language, enforce_wordlist=True, use_character_cipher=bool(not use_trezor_method))) self.init_device() return res @field('message') @expect(proto.Success) def reset_device(self, display_random, strength, passphrase_protection, pin_protection, label, language): if self.features.initialized: raise Exception("Device is initialized already. Call wipe_device() and try again.") # Begin with device reset workflow msg = proto.ResetDevice(display_random=display_random, strength=strength, language=language, passphrase_protection=bool(passphrase_protection), pin_protection=bool(pin_protection), label=label) resp = self.call(msg) if not isinstance(resp, proto.EntropyRequest): raise Exception("Invalid response, expected EntropyRequest") external_entropy = self._get_local_entropy() log("Computer generated entropy: " + binascii.hexlify(external_entropy)) ret = self.call(proto.EntropyAck(entropy=external_entropy)) self.init_device() return ret @field('message') @expect(proto.Success) def load_device_by_mnemonic(self, mnemonic, pin, passphrase_protection, label, language, skip_checksum=False): m = Mnemonic('english') if not skip_checksum and not m.check(mnemonic): raise Exception("Invalid mnemonic checksum") # Convert mnemonic to UTF8 NKFD mnemonic = Mnemonic.normalize_string(mnemonic) # Convert mnemonic to ASCII stream mnemonic = normalize_nfc(mnemonic) if self.features.initialized: raise Exception("Device is initialized already. Call wipe_device() and try again.") resp = self.call(proto.LoadDevice(mnemonic=mnemonic, pin=pin, passphrase_protection=passphrase_protection, language=language, label=label, skip_checksum=skip_checksum)) self.init_device() return resp @field('message') @expect(proto.Success) def load_device_by_xprv(self, xprv, pin, passphrase_protection, label, language): if self.features.initialized: raise Exception("Device is initialized already. Call wipe_device() and try again.") if xprv[0:4] not in ('xprv', 'tprv'): raise Exception("Unknown type of xprv") if len(xprv) < 100 and len(xprv) > 112: raise Exception("Invalid length of xprv") node = types.HDNodeType() data = binascii.hexlify(tools.b58decode(xprv, None)) if data[90:92] != '00': raise Exception("Contain invalid private key") checksum = hashlib.sha256(hashlib.sha256(binascii.unhexlify(data[:156])).digest()).hexdigest()[:8] if checksum != data[156:]: raise Exception("Checksum doesn't match") # version 0488ade4 # depth 00 # fingerprint 00000000 # child_num 00000000 # chaincode 873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508 # privkey 00e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35 # checksum e77e9d71 node.depth = int(data[8:10], 16) node.fingerprint = int(data[10:18], 16) node.child_num = int(data[18:26], 16) node.chain_code = data[26:90].decode('hex') node.private_key = data[92:156].decode('hex') # skip 0x00 indicating privkey resp = self.call(proto.LoadDevice(node=node, pin=pin, passphrase_protection=passphrase_protection, language=language, label=label)) self.init_device() return resp def firmware_update(self, fp): if self.features.bootloader_mode == False: raise Exception("Device must be in bootloader mode") resp = self.call(proto.FirmwareErase()) if isinstance(resp, proto.Failure) and resp.code == types.Failure_FirmwareError: return False data = fp.read() data_hash = hashlib.sha256(data).digest() resp = self.call(proto.FirmwareUpload(payload_hash=data_hash, payload=data)) if isinstance(resp, proto.Success): return True elif isinstance(resp, proto.Failure) and resp.code == types.Failure_FirmwareError: return False raise Exception("Unexpected result %s" % resp) class KeepKeyClient(ProtocolMixin, TextUIMixin, BaseClient): pass class KeepKeyClientDebug(ProtocolMixin, TextUIMixin, DebugWireMixin, BaseClient): pass class KeepKeyDebugClient(ProtocolMixin, DebugLinkMixin, DebugWireMixin, BaseClient): pass keepkey-0.7.3/keepkeylib/debuglink.py0000644000076500000240000000645612726074236020064 0ustar darinstaff00000000000000from __future__ import print_function from . import messages_pb2 as proto from .transport import NotImplementedException def pin_info(pin): print("Device asks for PIN %s" % pin) def button_press(yes_no): print("User pressed", '"y"' if yes_no else '"n"') def pprint(msg): return "<%s> (%d bytes):\n%s" % (msg.__class__.__name__, msg.ByteSize(), msg) class DebugLink(object): def __init__(self, transport, pin_func=pin_info, button_func=button_press): self.transport = transport self.pin_func = pin_func self.button_func = button_func def close(self): self.transport.close() def _call(self, msg, nowait=False): print("DEBUGLINK SEND", pprint(msg)) self.transport.write(msg) if nowait: return ret = self.transport.read_blocking() print("DEBUGLINK RECV", pprint(ret)) return ret def read_pin(self): obj = self._call(proto.DebugLinkGetState()) print("Read PIN:", obj.pin) print("Read matrix:", obj.matrix) return (obj.pin, obj.matrix) def read_pin_encoded(self): pin, _ = self.read_pin() pin_encoded = self.encode_pin(pin) self.pin_func(pin_encoded) return pin_encoded def encode_pin(self, pin): _, matrix = self.read_pin() # Now we have real PIN and PIN matrix. # We have to encode that into encoded pin, # because application must send back positions # on keypad, not a real PIN. pin_encoded = ''.join([str(matrix.index(p) + 1) for p in pin]) print("Encoded PIN:", pin_encoded) return pin_encoded def read_layout(self): obj = self._call(proto.DebugLinkGetState()) return obj.layout def read_mnemonic(self): obj = self._call(proto.DebugLinkGetState()) return obj.mnemonic def read_node(self): obj = self._call(proto.DebugLinkGetState()) return obj.node def read_recovery_word(self): obj = self._call(proto.DebugLinkGetState()) return (obj.recovery_fake_word, obj.recovery_word_pos) def read_reset_word(self): obj = self._call(proto.DebugLinkGetState()) return obj.reset_word def read_reset_entropy(self): obj = self._call(proto.DebugLinkGetState()) return obj.reset_entropy def read_passphrase_protection(self): obj = self._call(proto.DebugLinkGetState()) return obj.passphrase_protection def read_recovery_cipher(self): obj = self._call(proto.DebugLinkGetState()) return obj.recovery_cipher def read_recovery_auto_completed_word(self): obj = self._call(proto.DebugLinkGetState()) return obj.recovery_auto_completed_word def read_memory_hashes(self): obj = self._call(proto.DebugLinkGetState()) return (obj.firmware_hash, obj.storage_hash) def fill_config(self): self._call(proto.DebugLinkFillConfig(), nowait=True) def press_button(self, yes_no): print("Pressing", yes_no) self.button_func(yes_no) self._call(proto.DebugLinkDecision(yes_no=yes_no), nowait=True) def press_yes(self): self.press_button(True) def press_no(self): self.press_button(False) def stop(self): self._call(proto.DebugLinkStop(), nowait=True) keepkey-0.7.3/keepkeylib/mapping.py0000644000076500000240000000157012726074236017543 0ustar darinstaff00000000000000from . import messages_pb2 as proto map_type_to_class = {} map_class_to_type = {} def build_map(): for msg_type, i in proto.MessageType.items(): msg_name = msg_type.replace('MessageType_', '') msg_class = getattr(proto, msg_name) map_type_to_class[i] = msg_class map_class_to_type[msg_class] = i def get_type(msg): return map_class_to_type[msg.__class__] def get_class(t): return map_type_to_class[t] def check_missing(): from google.protobuf import reflection types = [getattr(proto, item) for item in dir(proto) if issubclass(getattr(proto, item).__class__, reflection.GeneratedProtocolMessageType)] missing = list(set(types) - set(map_type_to_class.values())) if len(missing): raise Exception("Following protobuf messages are not defined in mapping: %s" % missing) build_map() check_missing() keepkey-0.7.3/keepkeylib/messages_pb2.py0000644000076500000240000035621112717427115020465 0ustar darinstaff00000000000000# Generated by the protocol buffer compiler. DO NOT EDIT! # source: messages.proto from google.protobuf.internal import enum_type_wrapper from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import descriptor_pb2 # @@protoc_insertion_point(imports) import types_pb2 DESCRIPTOR = _descriptor.FileDescriptor( name='messages.proto', package='', serialized_pb='\n\x0emessages.proto\x1a\x0btypes.proto\"\x0c\n\nInitialize\"\r\n\x0bGetFeatures\"\xfe\x02\n\x08\x46\x65\x61tures\x12\x0e\n\x06vendor\x18\x01 \x01(\t\x12\x15\n\rmajor_version\x18\x02 \x01(\r\x12\x15\n\rminor_version\x18\x03 \x01(\r\x12\x15\n\rpatch_version\x18\x04 \x01(\r\x12\x17\n\x0f\x62ootloader_mode\x18\x05 \x01(\x08\x12\x11\n\tdevice_id\x18\x06 \x01(\t\x12\x16\n\x0epin_protection\x18\x07 \x01(\x08\x12\x1d\n\x15passphrase_protection\x18\x08 \x01(\x08\x12\x10\n\x08language\x18\t \x01(\t\x12\r\n\x05label\x18\n \x01(\t\x12\x18\n\x05\x63oins\x18\x0b \x03(\x0b\x32\t.CoinType\x12\x13\n\x0binitialized\x18\x0c \x01(\x08\x12\x10\n\x08revision\x18\r \x01(\x0c\x12\x17\n\x0f\x62ootloader_hash\x18\x0e \x01(\x0c\x12\x10\n\x08imported\x18\x0f \x01(\x08\x12\x12\n\npin_cached\x18\x10 \x01(\x08\x12\x19\n\x11passphrase_cached\x18\x11 \x01(\x08\"\x0e\n\x0c\x43learSession\"H\n\rApplySettings\x12\x10\n\x08language\x18\x01 \x01(\t\x12\r\n\x05label\x18\x02 \x01(\t\x12\x16\n\x0euse_passphrase\x18\x03 \x01(\x08\"\x1b\n\tChangePin\x12\x0e\n\x06remove\x18\x01 \x01(\x08\"i\n\x04Ping\x12\x0f\n\x07message\x18\x01 \x01(\t\x12\x19\n\x11\x62utton_protection\x18\x02 \x01(\x08\x12\x16\n\x0epin_protection\x18\x03 \x01(\x08\x12\x1d\n\x15passphrase_protection\x18\x04 \x01(\x08\"\x1a\n\x07Success\x12\x0f\n\x07message\x18\x01 \x01(\t\"6\n\x07\x46\x61ilure\x12\x1a\n\x04\x63ode\x18\x01 \x01(\x0e\x32\x0c.FailureType\x12\x0f\n\x07message\x18\x02 \x01(\t\"?\n\rButtonRequest\x12 \n\x04\x63ode\x18\x01 \x01(\x0e\x32\x12.ButtonRequestType\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\t\"\x0b\n\tButtonAck\"7\n\x10PinMatrixRequest\x12#\n\x04type\x18\x01 \x01(\x0e\x32\x15.PinMatrixRequestType\"\x1b\n\x0cPinMatrixAck\x12\x0b\n\x03pin\x18\x01 \x02(\t\"\x08\n\x06\x43\x61ncel\"\x13\n\x11PassphraseRequest\"#\n\rPassphraseAck\x12\x12\n\npassphrase\x18\x01 \x02(\t\"\x1a\n\nGetEntropy\x12\x0c\n\x04size\x18\x01 \x02(\r\"\x1a\n\x07\x45ntropy\x12\x0f\n\x07\x65ntropy\x18\x01 \x02(\x0c\"Q\n\x0cGetPublicKey\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\x18\n\x10\x65\x63\x64sa_curve_name\x18\x02 \x01(\t\x12\x14\n\x0cshow_display\x18\x03 \x01(\x08\"4\n\tPublicKey\x12\x19\n\x04node\x18\x01 \x02(\x0b\x32\x0b.HDNodeType\x12\x0c\n\x04xpub\x18\x02 \x01(\t\"~\n\nGetAddress\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\x1a\n\tcoin_name\x18\x02 \x01(\t:\x07\x42itcoin\x12\x14\n\x0cshow_display\x18\x03 \x01(\x08\x12+\n\x08multisig\x18\x04 \x01(\x0b\x32\x19.MultisigRedeemScriptType\"\x1a\n\x07\x41\x64\x64ress\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x02(\t\"\x0c\n\nWipeDevice\"\xa6\x01\n\nLoadDevice\x12\x10\n\x08mnemonic\x18\x01 \x01(\t\x12\x19\n\x04node\x18\x02 \x01(\x0b\x32\x0b.HDNodeType\x12\x0b\n\x03pin\x18\x03 \x01(\t\x12\x1d\n\x15passphrase_protection\x18\x04 \x01(\x08\x12\x19\n\x08language\x18\x05 \x01(\t:\x07\x65nglish\x12\r\n\x05label\x18\x06 \x01(\t\x12\x15\n\rskip_checksum\x18\x07 \x01(\x08\"\x9d\x01\n\x0bResetDevice\x12\x16\n\x0e\x64isplay_random\x18\x01 \x01(\x08\x12\x15\n\x08strength\x18\x02 \x01(\r:\x03\x32\x35\x36\x12\x1d\n\x15passphrase_protection\x18\x03 \x01(\x08\x12\x16\n\x0epin_protection\x18\x04 \x01(\x08\x12\x19\n\x08language\x18\x05 \x01(\t:\x07\x65nglish\x12\r\n\x05label\x18\x06 \x01(\t\"\x10\n\x0e\x45ntropyRequest\"\x1d\n\nEntropyAck\x12\x0f\n\x07\x65ntropy\x18\x01 \x01(\x0c\"\xbd\x01\n\x0eRecoveryDevice\x12\x12\n\nword_count\x18\x01 \x01(\r\x12\x1d\n\x15passphrase_protection\x18\x02 \x01(\x08\x12\x16\n\x0epin_protection\x18\x03 \x01(\x08\x12\x19\n\x08language\x18\x04 \x01(\t:\x07\x65nglish\x12\r\n\x05label\x18\x05 \x01(\t\x12\x18\n\x10\x65nforce_wordlist\x18\x06 \x01(\x08\x12\x1c\n\x14use_character_cipher\x18\x07 \x01(\x08\"\r\n\x0bWordRequest\"\x17\n\x07WordAck\x12\x0c\n\x04word\x18\x01 \x02(\t\";\n\x10\x43haracterRequest\x12\x10\n\x08word_pos\x18\x01 \x02(\r\x12\x15\n\rcharacter_pos\x18\x02 \x02(\r\"?\n\x0c\x43haracterAck\x12\x11\n\tcharacter\x18\x01 \x01(\t\x12\x0e\n\x06\x64\x65lete\x18\x02 \x01(\x08\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\"M\n\x0bSignMessage\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\x0f\n\x07message\x18\x02 \x02(\x0c\x12\x1a\n\tcoin_name\x18\x03 \x01(\t:\x07\x42itcoin\"D\n\rVerifyMessage\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x11\n\tsignature\x18\x02 \x01(\x0c\x12\x0f\n\x07message\x18\x03 \x01(\x0c\"6\n\x10MessageSignature\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x11\n\tsignature\x18\x02 \x01(\x0c\"v\n\x0e\x45ncryptMessage\x12\x0e\n\x06pubkey\x18\x01 \x01(\x0c\x12\x0f\n\x07message\x18\x02 \x01(\x0c\x12\x14\n\x0c\x64isplay_only\x18\x03 \x01(\x08\x12\x11\n\taddress_n\x18\x04 \x03(\r\x12\x1a\n\tcoin_name\x18\x05 \x01(\t:\x07\x42itcoin\"@\n\x10\x45ncryptedMessage\x12\r\n\x05nonce\x18\x01 \x01(\x0c\x12\x0f\n\x07message\x18\x02 \x01(\x0c\x12\x0c\n\x04hmac\x18\x03 \x01(\x0c\"Q\n\x0e\x44\x65\x63ryptMessage\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\r\n\x05nonce\x18\x02 \x01(\x0c\x12\x0f\n\x07message\x18\x03 \x01(\x0c\x12\x0c\n\x04hmac\x18\x04 \x01(\x0c\"4\n\x10\x44\x65\x63ryptedMessage\x12\x0f\n\x07message\x18\x01 \x01(\x0c\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\"\x8c\x01\n\x0e\x43ipherKeyValue\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\x0b\n\x03key\x18\x02 \x01(\t\x12\r\n\x05value\x18\x03 \x01(\x0c\x12\x0f\n\x07\x65ncrypt\x18\x04 \x01(\x08\x12\x16\n\x0e\x61sk_on_encrypt\x18\x05 \x01(\x08\x12\x16\n\x0e\x61sk_on_decrypt\x18\x06 \x01(\x08\x12\n\n\x02iv\x18\x07 \x01(\x0c\"!\n\x10\x43ipheredKeyValue\x12\r\n\x05value\x18\x01 \x01(\x0c\"Y\n\x0e\x45stimateTxSize\x12\x15\n\routputs_count\x18\x01 \x02(\r\x12\x14\n\x0cinputs_count\x18\x02 \x02(\r\x12\x1a\n\tcoin_name\x18\x03 \x01(\t:\x07\x42itcoin\"\x19\n\x06TxSize\x12\x0f\n\x07tx_size\x18\x01 \x01(\r\"Q\n\x06SignTx\x12\x15\n\routputs_count\x18\x01 \x02(\r\x12\x14\n\x0cinputs_count\x18\x02 \x02(\r\x12\x1a\n\tcoin_name\x18\x03 \x01(\t:\x07\x42itcoin\"\x90\x01\n\x0cSimpleSignTx\x12\x1c\n\x06inputs\x18\x01 \x03(\x0b\x32\x0c.TxInputType\x12\x1e\n\x07outputs\x18\x02 \x03(\x0b\x32\r.TxOutputType\x12&\n\x0ctransactions\x18\x03 \x03(\x0b\x32\x10.TransactionType\x12\x1a\n\tcoin_name\x18\x04 \x01(\t:\x07\x42itcoin\"\x85\x01\n\tTxRequest\x12\"\n\x0crequest_type\x18\x01 \x01(\x0e\x32\x0c.RequestType\x12&\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32\x15.TxRequestDetailsType\x12,\n\nserialized\x18\x03 \x01(\x0b\x32\x18.TxRequestSerializedType\"%\n\x05TxAck\x12\x1c\n\x02tx\x18\x01 \x01(\x0b\x32\x10.TransactionType\"}\n\x0cSignIdentity\x12\x1f\n\x08identity\x18\x01 \x01(\x0b\x32\r.IdentityType\x12\x18\n\x10\x63hallenge_hidden\x18\x02 \x01(\x0c\x12\x18\n\x10\x63hallenge_visual\x18\x03 \x01(\t\x12\x18\n\x10\x65\x63\x64sa_curve_name\x18\x04 \x01(\t\"H\n\x0eSignedIdentity\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x12\n\npublic_key\x18\x02 \x01(\x0c\x12\x11\n\tsignature\x18\x03 \x01(\x0c\"\x0f\n\rFirmwareErase\"7\n\x0e\x46irmwareUpload\x12\x14\n\x0cpayload_hash\x18\x01 \x02(\x0c\x12\x0f\n\x07payload\x18\x02 \x02(\x0c\"#\n\x11\x44\x65\x62ugLinkDecision\x12\x0e\n\x06yes_no\x18\x01 \x02(\x08\"\x13\n\x11\x44\x65\x62ugLinkGetState\"\xd7\x02\n\x0e\x44\x65\x62ugLinkState\x12\x0e\n\x06layout\x18\x01 \x01(\x0c\x12\x0b\n\x03pin\x18\x02 \x01(\t\x12\x0e\n\x06matrix\x18\x03 \x01(\t\x12\x10\n\x08mnemonic\x18\x04 \x01(\t\x12\x19\n\x04node\x18\x05 \x01(\x0b\x32\x0b.HDNodeType\x12\x1d\n\x15passphrase_protection\x18\x06 \x01(\x08\x12\x12\n\nreset_word\x18\x07 \x01(\t\x12\x15\n\rreset_entropy\x18\x08 \x01(\x0c\x12\x1a\n\x12recovery_fake_word\x18\t \x01(\t\x12\x19\n\x11recovery_word_pos\x18\n \x01(\r\x12\x17\n\x0frecovery_cipher\x18\x0b \x01(\t\x12$\n\x1crecovery_auto_completed_word\x18\x0c \x01(\t\x12\x15\n\rfirmware_hash\x18\r \x01(\x0c\x12\x14\n\x0cstorage_hash\x18\x0e \x01(\x0c\"\x0f\n\rDebugLinkStop\";\n\x0c\x44\x65\x62ugLinkLog\x12\r\n\x05level\x18\x01 \x01(\r\x12\x0e\n\x06\x62ucket\x18\x02 \x01(\t\x12\x0c\n\x04text\x18\x03 \x01(\t\"\x15\n\x13\x44\x65\x62ugLinkFillConfig*\xfd\x0f\n\x0bMessageType\x12 \n\x16MessageType_Initialize\x10\x00\x1a\x04\x90\xb5\x18\x01\x12\x1a\n\x10MessageType_Ping\x10\x01\x1a\x04\x90\xb5\x18\x01\x12\x1d\n\x13MessageType_Success\x10\x02\x1a\x04\x98\xb5\x18\x01\x12\x1d\n\x13MessageType_Failure\x10\x03\x1a\x04\x98\xb5\x18\x01\x12\x1f\n\x15MessageType_ChangePin\x10\x04\x1a\x04\x90\xb5\x18\x01\x12 \n\x16MessageType_WipeDevice\x10\x05\x1a\x04\x90\xb5\x18\x01\x12#\n\x19MessageType_FirmwareErase\x10\x06\x1a\x04\x90\xb5\x18\x01\x12$\n\x1aMessageType_FirmwareUpload\x10\x07\x1a\x04\x90\xb5\x18\x01\x12 \n\x16MessageType_GetEntropy\x10\t\x1a\x04\x90\xb5\x18\x01\x12\x1d\n\x13MessageType_Entropy\x10\n\x1a\x04\x98\xb5\x18\x01\x12\"\n\x18MessageType_GetPublicKey\x10\x0b\x1a\x04\x90\xb5\x18\x01\x12\x1f\n\x15MessageType_PublicKey\x10\x0c\x1a\x04\x98\xb5\x18\x01\x12 \n\x16MessageType_LoadDevice\x10\r\x1a\x04\x90\xb5\x18\x01\x12!\n\x17MessageType_ResetDevice\x10\x0e\x1a\x04\x90\xb5\x18\x01\x12\x1c\n\x12MessageType_SignTx\x10\x0f\x1a\x04\x90\xb5\x18\x01\x12\"\n\x18MessageType_SimpleSignTx\x10\x10\x1a\x04\x90\xb5\x18\x01\x12\x1e\n\x14MessageType_Features\x10\x11\x1a\x04\x98\xb5\x18\x01\x12&\n\x1cMessageType_PinMatrixRequest\x10\x12\x1a\x04\x98\xb5\x18\x01\x12\"\n\x18MessageType_PinMatrixAck\x10\x13\x1a\x04\x90\xb5\x18\x01\x12\x1c\n\x12MessageType_Cancel\x10\x14\x1a\x04\x90\xb5\x18\x01\x12\x1f\n\x15MessageType_TxRequest\x10\x15\x1a\x04\x98\xb5\x18\x01\x12\x1b\n\x11MessageType_TxAck\x10\x16\x1a\x04\x90\xb5\x18\x01\x12$\n\x1aMessageType_CipherKeyValue\x10\x17\x1a\x04\x90\xb5\x18\x01\x12\"\n\x18MessageType_ClearSession\x10\x18\x1a\x04\x90\xb5\x18\x01\x12#\n\x19MessageType_ApplySettings\x10\x19\x1a\x04\x90\xb5\x18\x01\x12#\n\x19MessageType_ButtonRequest\x10\x1a\x1a\x04\x98\xb5\x18\x01\x12\x1f\n\x15MessageType_ButtonAck\x10\x1b\x1a\x04\x90\xb5\x18\x01\x12 \n\x16MessageType_GetAddress\x10\x1d\x1a\x04\x90\xb5\x18\x01\x12\x1d\n\x13MessageType_Address\x10\x1e\x1a\x04\x98\xb5\x18\x01\x12$\n\x1aMessageType_EntropyRequest\x10#\x1a\x04\x98\xb5\x18\x01\x12 \n\x16MessageType_EntropyAck\x10$\x1a\x04\x90\xb5\x18\x01\x12!\n\x17MessageType_SignMessage\x10&\x1a\x04\x90\xb5\x18\x01\x12#\n\x19MessageType_VerifyMessage\x10\'\x1a\x04\x90\xb5\x18\x01\x12&\n\x1cMessageType_MessageSignature\x10(\x1a\x04\x98\xb5\x18\x01\x12\'\n\x1dMessageType_PassphraseRequest\x10)\x1a\x04\x98\xb5\x18\x01\x12#\n\x19MessageType_PassphraseAck\x10*\x1a\x04\x90\xb5\x18\x01\x12$\n\x1aMessageType_EstimateTxSize\x10+\x1a\x04\x90\xb5\x18\x01\x12\x1c\n\x12MessageType_TxSize\x10,\x1a\x04\x98\xb5\x18\x01\x12$\n\x1aMessageType_RecoveryDevice\x10-\x1a\x04\x90\xb5\x18\x01\x12!\n\x17MessageType_WordRequest\x10.\x1a\x04\x98\xb5\x18\x01\x12\x1d\n\x13MessageType_WordAck\x10/\x1a\x04\x90\xb5\x18\x01\x12&\n\x1cMessageType_CipheredKeyValue\x10\x30\x1a\x04\x98\xb5\x18\x01\x12$\n\x1aMessageType_EncryptMessage\x10\x31\x1a\x04\x90\xb5\x18\x01\x12&\n\x1cMessageType_EncryptedMessage\x10\x32\x1a\x04\x98\xb5\x18\x01\x12$\n\x1aMessageType_DecryptMessage\x10\x33\x1a\x04\x90\xb5\x18\x01\x12&\n\x1cMessageType_DecryptedMessage\x10\x34\x1a\x04\x98\xb5\x18\x01\x12\"\n\x18MessageType_SignIdentity\x10\x35\x1a\x04\x90\xb5\x18\x01\x12$\n\x1aMessageType_SignedIdentity\x10\x36\x1a\x04\x98\xb5\x18\x01\x12!\n\x17MessageType_GetFeatures\x10\x37\x1a\x04\x90\xb5\x18\x01\x12&\n\x1cMessageType_CharacterRequest\x10P\x1a\x04\x98\xb5\x18\x01\x12\"\n\x18MessageType_CharacterAck\x10Q\x1a\x04\x90\xb5\x18\x01\x12\'\n\x1dMessageType_DebugLinkDecision\x10\x64\x1a\x04\xa0\xb5\x18\x01\x12\'\n\x1dMessageType_DebugLinkGetState\x10\x65\x1a\x04\xa0\xb5\x18\x01\x12$\n\x1aMessageType_DebugLinkState\x10\x66\x1a\x04\xa8\xb5\x18\x01\x12#\n\x19MessageType_DebugLinkStop\x10g\x1a\x04\xa0\xb5\x18\x01\x12\"\n\x18MessageType_DebugLinkLog\x10h\x1a\x04\xa8\xb5\x18\x01\x12)\n\x1fMessageType_DebugLinkFillConfig\x10i\x1a\x04\xa8\xb5\x18\x01\x42-\n\x1b\x63om.keepkey.device-protocolB\x0eKeepKeyMessage') _MESSAGETYPE = _descriptor.EnumDescriptor( name='MessageType', full_name='MessageType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='MessageType_Initialize', index=0, number=0, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Ping', index=1, number=1, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Success', index=2, number=2, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Failure', index=3, number=3, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ChangePin', index=4, number=4, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_WipeDevice', index=5, number=5, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_FirmwareErase', index=6, number=6, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_FirmwareUpload', index=7, number=7, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_GetEntropy', index=8, number=9, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Entropy', index=9, number=10, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_GetPublicKey', index=10, number=11, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_PublicKey', index=11, number=12, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_LoadDevice', index=12, number=13, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ResetDevice', index=13, number=14, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_SignTx', index=14, number=15, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_SimpleSignTx', index=15, number=16, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Features', index=16, number=17, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_PinMatrixRequest', index=17, number=18, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_PinMatrixAck', index=18, number=19, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Cancel', index=19, number=20, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_TxRequest', index=20, number=21, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_TxAck', index=21, number=22, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_CipherKeyValue', index=22, number=23, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ClearSession', index=23, number=24, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ApplySettings', index=24, number=25, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ButtonRequest', index=25, number=26, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_ButtonAck', index=26, number=27, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_GetAddress', index=27, number=29, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_Address', index=28, number=30, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_EntropyRequest', index=29, number=35, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_EntropyAck', index=30, number=36, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_SignMessage', index=31, number=38, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_VerifyMessage', index=32, number=39, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_MessageSignature', index=33, number=40, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_PassphraseRequest', index=34, number=41, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_PassphraseAck', index=35, number=42, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_EstimateTxSize', index=36, number=43, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_TxSize', index=37, number=44, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_RecoveryDevice', index=38, number=45, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_WordRequest', index=39, number=46, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_WordAck', index=40, number=47, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_CipheredKeyValue', index=41, number=48, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_EncryptMessage', index=42, number=49, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_EncryptedMessage', index=43, number=50, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DecryptMessage', index=44, number=51, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DecryptedMessage', index=45, number=52, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_SignIdentity', index=46, number=53, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_SignedIdentity', index=47, number=54, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_GetFeatures', index=48, number=55, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_CharacterRequest', index=49, number=80, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_CharacterAck', index=50, number=81, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkDecision', index=51, number=100, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkGetState', index=52, number=101, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkState', index=53, number=102, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkStop', index=54, number=103, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkLog', index=55, number=104, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001'), type=None), _descriptor.EnumValueDescriptor( name='MessageType_DebugLinkFillConfig', index=56, number=105, options=_descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001'), type=None), ], containing_type=None, options=None, serialized_start=4096, serialized_end=6141, ) MessageType = enum_type_wrapper.EnumTypeWrapper(_MESSAGETYPE) MessageType_Initialize = 0 MessageType_Ping = 1 MessageType_Success = 2 MessageType_Failure = 3 MessageType_ChangePin = 4 MessageType_WipeDevice = 5 MessageType_FirmwareErase = 6 MessageType_FirmwareUpload = 7 MessageType_GetEntropy = 9 MessageType_Entropy = 10 MessageType_GetPublicKey = 11 MessageType_PublicKey = 12 MessageType_LoadDevice = 13 MessageType_ResetDevice = 14 MessageType_SignTx = 15 MessageType_SimpleSignTx = 16 MessageType_Features = 17 MessageType_PinMatrixRequest = 18 MessageType_PinMatrixAck = 19 MessageType_Cancel = 20 MessageType_TxRequest = 21 MessageType_TxAck = 22 MessageType_CipherKeyValue = 23 MessageType_ClearSession = 24 MessageType_ApplySettings = 25 MessageType_ButtonRequest = 26 MessageType_ButtonAck = 27 MessageType_GetAddress = 29 MessageType_Address = 30 MessageType_EntropyRequest = 35 MessageType_EntropyAck = 36 MessageType_SignMessage = 38 MessageType_VerifyMessage = 39 MessageType_MessageSignature = 40 MessageType_PassphraseRequest = 41 MessageType_PassphraseAck = 42 MessageType_EstimateTxSize = 43 MessageType_TxSize = 44 MessageType_RecoveryDevice = 45 MessageType_WordRequest = 46 MessageType_WordAck = 47 MessageType_CipheredKeyValue = 48 MessageType_EncryptMessage = 49 MessageType_EncryptedMessage = 50 MessageType_DecryptMessage = 51 MessageType_DecryptedMessage = 52 MessageType_SignIdentity = 53 MessageType_SignedIdentity = 54 MessageType_GetFeatures = 55 MessageType_CharacterRequest = 80 MessageType_CharacterAck = 81 MessageType_DebugLinkDecision = 100 MessageType_DebugLinkGetState = 101 MessageType_DebugLinkState = 102 MessageType_DebugLinkStop = 103 MessageType_DebugLinkLog = 104 MessageType_DebugLinkFillConfig = 105 _INITIALIZE = _descriptor.Descriptor( name='Initialize', full_name='Initialize', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=31, serialized_end=43, ) _GETFEATURES = _descriptor.Descriptor( name='GetFeatures', full_name='GetFeatures', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=45, serialized_end=58, ) _FEATURES = _descriptor.Descriptor( name='Features', full_name='Features', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='vendor', full_name='Features.vendor', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='major_version', full_name='Features.major_version', index=1, number=2, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='minor_version', full_name='Features.minor_version', index=2, number=3, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='patch_version', full_name='Features.patch_version', index=3, number=4, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='bootloader_mode', full_name='Features.bootloader_mode', index=4, number=5, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='device_id', full_name='Features.device_id', index=5, number=6, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin_protection', full_name='Features.pin_protection', index=6, number=7, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='Features.passphrase_protection', index=7, number=8, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='language', full_name='Features.language', index=8, number=9, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='label', full_name='Features.label', index=9, number=10, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coins', full_name='Features.coins', index=10, number=11, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='initialized', full_name='Features.initialized', index=11, number=12, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='revision', full_name='Features.revision', index=12, number=13, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='bootloader_hash', full_name='Features.bootloader_hash', index=13, number=14, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='imported', full_name='Features.imported', index=14, number=15, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin_cached', full_name='Features.pin_cached', index=15, number=16, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_cached', full_name='Features.passphrase_cached', index=16, number=17, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=61, serialized_end=443, ) _CLEARSESSION = _descriptor.Descriptor( name='ClearSession', full_name='ClearSession', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=445, serialized_end=459, ) _APPLYSETTINGS = _descriptor.Descriptor( name='ApplySettings', full_name='ApplySettings', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='language', full_name='ApplySettings.language', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='label', full_name='ApplySettings.label', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='use_passphrase', full_name='ApplySettings.use_passphrase', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=461, serialized_end=533, ) _CHANGEPIN = _descriptor.Descriptor( name='ChangePin', full_name='ChangePin', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='remove', full_name='ChangePin.remove', index=0, number=1, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=535, serialized_end=562, ) _PING = _descriptor.Descriptor( name='Ping', full_name='Ping', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='message', full_name='Ping.message', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='button_protection', full_name='Ping.button_protection', index=1, number=2, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin_protection', full_name='Ping.pin_protection', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='Ping.passphrase_protection', index=3, number=4, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=564, serialized_end=669, ) _SUCCESS = _descriptor.Descriptor( name='Success', full_name='Success', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='message', full_name='Success.message', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=671, serialized_end=697, ) _FAILURE = _descriptor.Descriptor( name='Failure', full_name='Failure', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='code', full_name='Failure.code', index=0, number=1, type=14, cpp_type=8, label=1, has_default_value=False, default_value=1, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='Failure.message', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=699, serialized_end=753, ) _BUTTONREQUEST = _descriptor.Descriptor( name='ButtonRequest', full_name='ButtonRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='code', full_name='ButtonRequest.code', index=0, number=1, type=14, cpp_type=8, label=1, has_default_value=False, default_value=1, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='data', full_name='ButtonRequest.data', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=755, serialized_end=818, ) _BUTTONACK = _descriptor.Descriptor( name='ButtonAck', full_name='ButtonAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=820, serialized_end=831, ) _PINMATRIXREQUEST = _descriptor.Descriptor( name='PinMatrixRequest', full_name='PinMatrixRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='type', full_name='PinMatrixRequest.type', index=0, number=1, type=14, cpp_type=8, label=1, has_default_value=False, default_value=1, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=833, serialized_end=888, ) _PINMATRIXACK = _descriptor.Descriptor( name='PinMatrixAck', full_name='PinMatrixAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='pin', full_name='PinMatrixAck.pin', index=0, number=1, type=9, cpp_type=9, label=2, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=890, serialized_end=917, ) _CANCEL = _descriptor.Descriptor( name='Cancel', full_name='Cancel', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=919, serialized_end=927, ) _PASSPHRASEREQUEST = _descriptor.Descriptor( name='PassphraseRequest', full_name='PassphraseRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=929, serialized_end=948, ) _PASSPHRASEACK = _descriptor.Descriptor( name='PassphraseAck', full_name='PassphraseAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='passphrase', full_name='PassphraseAck.passphrase', index=0, number=1, type=9, cpp_type=9, label=2, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=950, serialized_end=985, ) _GETENTROPY = _descriptor.Descriptor( name='GetEntropy', full_name='GetEntropy', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='size', full_name='GetEntropy.size', index=0, number=1, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=987, serialized_end=1013, ) _ENTROPY = _descriptor.Descriptor( name='Entropy', full_name='Entropy', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='entropy', full_name='Entropy.entropy', index=0, number=1, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1015, serialized_end=1041, ) _GETPUBLICKEY = _descriptor.Descriptor( name='GetPublicKey', full_name='GetPublicKey', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='GetPublicKey.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='ecdsa_curve_name', full_name='GetPublicKey.ecdsa_curve_name', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='show_display', full_name='GetPublicKey.show_display', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1043, serialized_end=1124, ) _PUBLICKEY = _descriptor.Descriptor( name='PublicKey', full_name='PublicKey', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='node', full_name='PublicKey.node', index=0, number=1, type=11, cpp_type=10, label=2, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='xpub', full_name='PublicKey.xpub', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1126, serialized_end=1178, ) _GETADDRESS = _descriptor.Descriptor( name='GetAddress', full_name='GetAddress', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='GetAddress.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='GetAddress.coin_name', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='show_display', full_name='GetAddress.show_display', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='multisig', full_name='GetAddress.multisig', index=3, number=4, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1180, serialized_end=1306, ) _ADDRESS = _descriptor.Descriptor( name='Address', full_name='Address', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address', full_name='Address.address', index=0, number=1, type=9, cpp_type=9, label=2, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1308, serialized_end=1334, ) _WIPEDEVICE = _descriptor.Descriptor( name='WipeDevice', full_name='WipeDevice', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1336, serialized_end=1348, ) _LOADDEVICE = _descriptor.Descriptor( name='LoadDevice', full_name='LoadDevice', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='mnemonic', full_name='LoadDevice.mnemonic', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='node', full_name='LoadDevice.node', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin', full_name='LoadDevice.pin', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='LoadDevice.passphrase_protection', index=3, number=4, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='language', full_name='LoadDevice.language', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("english", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='label', full_name='LoadDevice.label', index=5, number=6, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='skip_checksum', full_name='LoadDevice.skip_checksum', index=6, number=7, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1351, serialized_end=1517, ) _RESETDEVICE = _descriptor.Descriptor( name='ResetDevice', full_name='ResetDevice', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='display_random', full_name='ResetDevice.display_random', index=0, number=1, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='strength', full_name='ResetDevice.strength', index=1, number=2, type=13, cpp_type=3, label=1, has_default_value=True, default_value=256, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='ResetDevice.passphrase_protection', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin_protection', full_name='ResetDevice.pin_protection', index=3, number=4, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='language', full_name='ResetDevice.language', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("english", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='label', full_name='ResetDevice.label', index=5, number=6, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1520, serialized_end=1677, ) _ENTROPYREQUEST = _descriptor.Descriptor( name='EntropyRequest', full_name='EntropyRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1679, serialized_end=1695, ) _ENTROPYACK = _descriptor.Descriptor( name='EntropyAck', full_name='EntropyAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='entropy', full_name='EntropyAck.entropy', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1697, serialized_end=1726, ) _RECOVERYDEVICE = _descriptor.Descriptor( name='RecoveryDevice', full_name='RecoveryDevice', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='word_count', full_name='RecoveryDevice.word_count', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='RecoveryDevice.passphrase_protection', index=1, number=2, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin_protection', full_name='RecoveryDevice.pin_protection', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='language', full_name='RecoveryDevice.language', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("english", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='label', full_name='RecoveryDevice.label', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='enforce_wordlist', full_name='RecoveryDevice.enforce_wordlist', index=5, number=6, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='use_character_cipher', full_name='RecoveryDevice.use_character_cipher', index=6, number=7, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1729, serialized_end=1918, ) _WORDREQUEST = _descriptor.Descriptor( name='WordRequest', full_name='WordRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1920, serialized_end=1933, ) _WORDACK = _descriptor.Descriptor( name='WordAck', full_name='WordAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='word', full_name='WordAck.word', index=0, number=1, type=9, cpp_type=9, label=2, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1935, serialized_end=1958, ) _CHARACTERREQUEST = _descriptor.Descriptor( name='CharacterRequest', full_name='CharacterRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='word_pos', full_name='CharacterRequest.word_pos', index=0, number=1, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='character_pos', full_name='CharacterRequest.character_pos', index=1, number=2, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1960, serialized_end=2019, ) _CHARACTERACK = _descriptor.Descriptor( name='CharacterAck', full_name='CharacterAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='character', full_name='CharacterAck.character', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='delete', full_name='CharacterAck.delete', index=1, number=2, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='done', full_name='CharacterAck.done', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2021, serialized_end=2084, ) _SIGNMESSAGE = _descriptor.Descriptor( name='SignMessage', full_name='SignMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='SignMessage.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='SignMessage.message', index=1, number=2, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='SignMessage.coin_name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2086, serialized_end=2163, ) _VERIFYMESSAGE = _descriptor.Descriptor( name='VerifyMessage', full_name='VerifyMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address', full_name='VerifyMessage.address', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='signature', full_name='VerifyMessage.signature', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='VerifyMessage.message', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2165, serialized_end=2233, ) _MESSAGESIGNATURE = _descriptor.Descriptor( name='MessageSignature', full_name='MessageSignature', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address', full_name='MessageSignature.address', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='signature', full_name='MessageSignature.signature', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2235, serialized_end=2289, ) _ENCRYPTMESSAGE = _descriptor.Descriptor( name='EncryptMessage', full_name='EncryptMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='pubkey', full_name='EncryptMessage.pubkey', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='EncryptMessage.message', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='display_only', full_name='EncryptMessage.display_only', index=2, number=3, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_n', full_name='EncryptMessage.address_n', index=3, number=4, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='EncryptMessage.coin_name', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2291, serialized_end=2409, ) _ENCRYPTEDMESSAGE = _descriptor.Descriptor( name='EncryptedMessage', full_name='EncryptedMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='nonce', full_name='EncryptedMessage.nonce', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='EncryptedMessage.message', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='hmac', full_name='EncryptedMessage.hmac', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2411, serialized_end=2475, ) _DECRYPTMESSAGE = _descriptor.Descriptor( name='DecryptMessage', full_name='DecryptMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='DecryptMessage.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='nonce', full_name='DecryptMessage.nonce', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='message', full_name='DecryptMessage.message', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='hmac', full_name='DecryptMessage.hmac', index=3, number=4, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2477, serialized_end=2558, ) _DECRYPTEDMESSAGE = _descriptor.Descriptor( name='DecryptedMessage', full_name='DecryptedMessage', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='message', full_name='DecryptedMessage.message', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address', full_name='DecryptedMessage.address', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2560, serialized_end=2612, ) _CIPHERKEYVALUE = _descriptor.Descriptor( name='CipherKeyValue', full_name='CipherKeyValue', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='CipherKeyValue.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='key', full_name='CipherKeyValue.key', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='value', full_name='CipherKeyValue.value', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='encrypt', full_name='CipherKeyValue.encrypt', index=3, number=4, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='ask_on_encrypt', full_name='CipherKeyValue.ask_on_encrypt', index=4, number=5, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='ask_on_decrypt', full_name='CipherKeyValue.ask_on_decrypt', index=5, number=6, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='iv', full_name='CipherKeyValue.iv', index=6, number=7, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2615, serialized_end=2755, ) _CIPHEREDKEYVALUE = _descriptor.Descriptor( name='CipheredKeyValue', full_name='CipheredKeyValue', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='value', full_name='CipheredKeyValue.value', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2757, serialized_end=2790, ) _ESTIMATETXSIZE = _descriptor.Descriptor( name='EstimateTxSize', full_name='EstimateTxSize', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='outputs_count', full_name='EstimateTxSize.outputs_count', index=0, number=1, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='inputs_count', full_name='EstimateTxSize.inputs_count', index=1, number=2, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='EstimateTxSize.coin_name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2792, serialized_end=2881, ) _TXSIZE = _descriptor.Descriptor( name='TxSize', full_name='TxSize', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='tx_size', full_name='TxSize.tx_size', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2883, serialized_end=2908, ) _SIGNTX = _descriptor.Descriptor( name='SignTx', full_name='SignTx', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='outputs_count', full_name='SignTx.outputs_count', index=0, number=1, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='inputs_count', full_name='SignTx.inputs_count', index=1, number=2, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='SignTx.coin_name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2910, serialized_end=2991, ) _SIMPLESIGNTX = _descriptor.Descriptor( name='SimpleSignTx', full_name='SimpleSignTx', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='inputs', full_name='SimpleSignTx.inputs', index=0, number=1, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='outputs', full_name='SimpleSignTx.outputs', index=1, number=2, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='transactions', full_name='SimpleSignTx.transactions', index=2, number=3, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_name', full_name='SimpleSignTx.coin_name', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=True, default_value=unicode("Bitcoin", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=2994, serialized_end=3138, ) _TXREQUEST = _descriptor.Descriptor( name='TxRequest', full_name='TxRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='request_type', full_name='TxRequest.request_type', index=0, number=1, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='details', full_name='TxRequest.details', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='serialized', full_name='TxRequest.serialized', index=2, number=3, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3141, serialized_end=3274, ) _TXACK = _descriptor.Descriptor( name='TxAck', full_name='TxAck', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='tx', full_name='TxAck.tx', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3276, serialized_end=3313, ) _SIGNIDENTITY = _descriptor.Descriptor( name='SignIdentity', full_name='SignIdentity', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='identity', full_name='SignIdentity.identity', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='challenge_hidden', full_name='SignIdentity.challenge_hidden', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='challenge_visual', full_name='SignIdentity.challenge_visual', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='ecdsa_curve_name', full_name='SignIdentity.ecdsa_curve_name', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3315, serialized_end=3440, ) _SIGNEDIDENTITY = _descriptor.Descriptor( name='SignedIdentity', full_name='SignedIdentity', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address', full_name='SignedIdentity.address', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='public_key', full_name='SignedIdentity.public_key', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='signature', full_name='SignedIdentity.signature', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3442, serialized_end=3514, ) _FIRMWAREERASE = _descriptor.Descriptor( name='FirmwareErase', full_name='FirmwareErase', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3516, serialized_end=3531, ) _FIRMWAREUPLOAD = _descriptor.Descriptor( name='FirmwareUpload', full_name='FirmwareUpload', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='payload_hash', full_name='FirmwareUpload.payload_hash', index=0, number=1, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='payload', full_name='FirmwareUpload.payload', index=1, number=2, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3533, serialized_end=3588, ) _DEBUGLINKDECISION = _descriptor.Descriptor( name='DebugLinkDecision', full_name='DebugLinkDecision', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='yes_no', full_name='DebugLinkDecision.yes_no', index=0, number=1, type=8, cpp_type=7, label=2, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3590, serialized_end=3625, ) _DEBUGLINKGETSTATE = _descriptor.Descriptor( name='DebugLinkGetState', full_name='DebugLinkGetState', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3627, serialized_end=3646, ) _DEBUGLINKSTATE = _descriptor.Descriptor( name='DebugLinkState', full_name='DebugLinkState', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='layout', full_name='DebugLinkState.layout', index=0, number=1, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='pin', full_name='DebugLinkState.pin', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='matrix', full_name='DebugLinkState.matrix', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='mnemonic', full_name='DebugLinkState.mnemonic', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='node', full_name='DebugLinkState.node', index=4, number=5, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='passphrase_protection', full_name='DebugLinkState.passphrase_protection', index=5, number=6, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='reset_word', full_name='DebugLinkState.reset_word', index=6, number=7, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='reset_entropy', full_name='DebugLinkState.reset_entropy', index=7, number=8, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='recovery_fake_word', full_name='DebugLinkState.recovery_fake_word', index=8, number=9, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='recovery_word_pos', full_name='DebugLinkState.recovery_word_pos', index=9, number=10, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='recovery_cipher', full_name='DebugLinkState.recovery_cipher', index=10, number=11, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='recovery_auto_completed_word', full_name='DebugLinkState.recovery_auto_completed_word', index=11, number=12, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='firmware_hash', full_name='DebugLinkState.firmware_hash', index=12, number=13, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='storage_hash', full_name='DebugLinkState.storage_hash', index=13, number=14, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3649, serialized_end=3992, ) _DEBUGLINKSTOP = _descriptor.Descriptor( name='DebugLinkStop', full_name='DebugLinkStop', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=3994, serialized_end=4009, ) _DEBUGLINKLOG = _descriptor.Descriptor( name='DebugLinkLog', full_name='DebugLinkLog', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='level', full_name='DebugLinkLog.level', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='bucket', full_name='DebugLinkLog.bucket', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='text', full_name='DebugLinkLog.text', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=4011, serialized_end=4070, ) _DEBUGLINKFILLCONFIG = _descriptor.Descriptor( name='DebugLinkFillConfig', full_name='DebugLinkFillConfig', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=4072, serialized_end=4093, ) _FEATURES.fields_by_name['coins'].message_type = types_pb2._COINTYPE _FAILURE.fields_by_name['code'].enum_type = types_pb2._FAILURETYPE _BUTTONREQUEST.fields_by_name['code'].enum_type = types_pb2._BUTTONREQUESTTYPE _PINMATRIXREQUEST.fields_by_name['type'].enum_type = types_pb2._PINMATRIXREQUESTTYPE _PUBLICKEY.fields_by_name['node'].message_type = types_pb2._HDNODETYPE _GETADDRESS.fields_by_name['multisig'].message_type = types_pb2._MULTISIGREDEEMSCRIPTTYPE _LOADDEVICE.fields_by_name['node'].message_type = types_pb2._HDNODETYPE _SIMPLESIGNTX.fields_by_name['inputs'].message_type = types_pb2._TXINPUTTYPE _SIMPLESIGNTX.fields_by_name['outputs'].message_type = types_pb2._TXOUTPUTTYPE _SIMPLESIGNTX.fields_by_name['transactions'].message_type = types_pb2._TRANSACTIONTYPE _TXREQUEST.fields_by_name['request_type'].enum_type = types_pb2._REQUESTTYPE _TXREQUEST.fields_by_name['details'].message_type = types_pb2._TXREQUESTDETAILSTYPE _TXREQUEST.fields_by_name['serialized'].message_type = types_pb2._TXREQUESTSERIALIZEDTYPE _TXACK.fields_by_name['tx'].message_type = types_pb2._TRANSACTIONTYPE _SIGNIDENTITY.fields_by_name['identity'].message_type = types_pb2._IDENTITYTYPE _DEBUGLINKSTATE.fields_by_name['node'].message_type = types_pb2._HDNODETYPE DESCRIPTOR.message_types_by_name['Initialize'] = _INITIALIZE DESCRIPTOR.message_types_by_name['GetFeatures'] = _GETFEATURES DESCRIPTOR.message_types_by_name['Features'] = _FEATURES DESCRIPTOR.message_types_by_name['ClearSession'] = _CLEARSESSION DESCRIPTOR.message_types_by_name['ApplySettings'] = _APPLYSETTINGS DESCRIPTOR.message_types_by_name['ChangePin'] = _CHANGEPIN DESCRIPTOR.message_types_by_name['Ping'] = _PING DESCRIPTOR.message_types_by_name['Success'] = _SUCCESS DESCRIPTOR.message_types_by_name['Failure'] = _FAILURE DESCRIPTOR.message_types_by_name['ButtonRequest'] = _BUTTONREQUEST DESCRIPTOR.message_types_by_name['ButtonAck'] = _BUTTONACK DESCRIPTOR.message_types_by_name['PinMatrixRequest'] = _PINMATRIXREQUEST DESCRIPTOR.message_types_by_name['PinMatrixAck'] = _PINMATRIXACK DESCRIPTOR.message_types_by_name['Cancel'] = _CANCEL DESCRIPTOR.message_types_by_name['PassphraseRequest'] = _PASSPHRASEREQUEST DESCRIPTOR.message_types_by_name['PassphraseAck'] = _PASSPHRASEACK DESCRIPTOR.message_types_by_name['GetEntropy'] = _GETENTROPY DESCRIPTOR.message_types_by_name['Entropy'] = _ENTROPY DESCRIPTOR.message_types_by_name['GetPublicKey'] = _GETPUBLICKEY DESCRIPTOR.message_types_by_name['PublicKey'] = _PUBLICKEY DESCRIPTOR.message_types_by_name['GetAddress'] = _GETADDRESS DESCRIPTOR.message_types_by_name['Address'] = _ADDRESS DESCRIPTOR.message_types_by_name['WipeDevice'] = _WIPEDEVICE DESCRIPTOR.message_types_by_name['LoadDevice'] = _LOADDEVICE DESCRIPTOR.message_types_by_name['ResetDevice'] = _RESETDEVICE DESCRIPTOR.message_types_by_name['EntropyRequest'] = _ENTROPYREQUEST DESCRIPTOR.message_types_by_name['EntropyAck'] = _ENTROPYACK DESCRIPTOR.message_types_by_name['RecoveryDevice'] = _RECOVERYDEVICE DESCRIPTOR.message_types_by_name['WordRequest'] = _WORDREQUEST DESCRIPTOR.message_types_by_name['WordAck'] = _WORDACK DESCRIPTOR.message_types_by_name['CharacterRequest'] = _CHARACTERREQUEST DESCRIPTOR.message_types_by_name['CharacterAck'] = _CHARACTERACK DESCRIPTOR.message_types_by_name['SignMessage'] = _SIGNMESSAGE DESCRIPTOR.message_types_by_name['VerifyMessage'] = _VERIFYMESSAGE DESCRIPTOR.message_types_by_name['MessageSignature'] = _MESSAGESIGNATURE DESCRIPTOR.message_types_by_name['EncryptMessage'] = _ENCRYPTMESSAGE DESCRIPTOR.message_types_by_name['EncryptedMessage'] = _ENCRYPTEDMESSAGE DESCRIPTOR.message_types_by_name['DecryptMessage'] = _DECRYPTMESSAGE DESCRIPTOR.message_types_by_name['DecryptedMessage'] = _DECRYPTEDMESSAGE DESCRIPTOR.message_types_by_name['CipherKeyValue'] = _CIPHERKEYVALUE DESCRIPTOR.message_types_by_name['CipheredKeyValue'] = _CIPHEREDKEYVALUE DESCRIPTOR.message_types_by_name['EstimateTxSize'] = _ESTIMATETXSIZE DESCRIPTOR.message_types_by_name['TxSize'] = _TXSIZE DESCRIPTOR.message_types_by_name['SignTx'] = _SIGNTX DESCRIPTOR.message_types_by_name['SimpleSignTx'] = _SIMPLESIGNTX DESCRIPTOR.message_types_by_name['TxRequest'] = _TXREQUEST DESCRIPTOR.message_types_by_name['TxAck'] = _TXACK DESCRIPTOR.message_types_by_name['SignIdentity'] = _SIGNIDENTITY DESCRIPTOR.message_types_by_name['SignedIdentity'] = _SIGNEDIDENTITY DESCRIPTOR.message_types_by_name['FirmwareErase'] = _FIRMWAREERASE DESCRIPTOR.message_types_by_name['FirmwareUpload'] = _FIRMWAREUPLOAD DESCRIPTOR.message_types_by_name['DebugLinkDecision'] = _DEBUGLINKDECISION DESCRIPTOR.message_types_by_name['DebugLinkGetState'] = _DEBUGLINKGETSTATE DESCRIPTOR.message_types_by_name['DebugLinkState'] = _DEBUGLINKSTATE DESCRIPTOR.message_types_by_name['DebugLinkStop'] = _DEBUGLINKSTOP DESCRIPTOR.message_types_by_name['DebugLinkLog'] = _DEBUGLINKLOG DESCRIPTOR.message_types_by_name['DebugLinkFillConfig'] = _DEBUGLINKFILLCONFIG class Initialize(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _INITIALIZE # @@protoc_insertion_point(class_scope:Initialize) class GetFeatures(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _GETFEATURES # @@protoc_insertion_point(class_scope:GetFeatures) class Features(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _FEATURES # @@protoc_insertion_point(class_scope:Features) class ClearSession(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CLEARSESSION # @@protoc_insertion_point(class_scope:ClearSession) class ApplySettings(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _APPLYSETTINGS # @@protoc_insertion_point(class_scope:ApplySettings) class ChangePin(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CHANGEPIN # @@protoc_insertion_point(class_scope:ChangePin) class Ping(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PING # @@protoc_insertion_point(class_scope:Ping) class Success(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SUCCESS # @@protoc_insertion_point(class_scope:Success) class Failure(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _FAILURE # @@protoc_insertion_point(class_scope:Failure) class ButtonRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _BUTTONREQUEST # @@protoc_insertion_point(class_scope:ButtonRequest) class ButtonAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _BUTTONACK # @@protoc_insertion_point(class_scope:ButtonAck) class PinMatrixRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PINMATRIXREQUEST # @@protoc_insertion_point(class_scope:PinMatrixRequest) class PinMatrixAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PINMATRIXACK # @@protoc_insertion_point(class_scope:PinMatrixAck) class Cancel(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CANCEL # @@protoc_insertion_point(class_scope:Cancel) class PassphraseRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PASSPHRASEREQUEST # @@protoc_insertion_point(class_scope:PassphraseRequest) class PassphraseAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PASSPHRASEACK # @@protoc_insertion_point(class_scope:PassphraseAck) class GetEntropy(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _GETENTROPY # @@protoc_insertion_point(class_scope:GetEntropy) class Entropy(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ENTROPY # @@protoc_insertion_point(class_scope:Entropy) class GetPublicKey(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _GETPUBLICKEY # @@protoc_insertion_point(class_scope:GetPublicKey) class PublicKey(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _PUBLICKEY # @@protoc_insertion_point(class_scope:PublicKey) class GetAddress(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _GETADDRESS # @@protoc_insertion_point(class_scope:GetAddress) class Address(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ADDRESS # @@protoc_insertion_point(class_scope:Address) class WipeDevice(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _WIPEDEVICE # @@protoc_insertion_point(class_scope:WipeDevice) class LoadDevice(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _LOADDEVICE # @@protoc_insertion_point(class_scope:LoadDevice) class ResetDevice(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _RESETDEVICE # @@protoc_insertion_point(class_scope:ResetDevice) class EntropyRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ENTROPYREQUEST # @@protoc_insertion_point(class_scope:EntropyRequest) class EntropyAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ENTROPYACK # @@protoc_insertion_point(class_scope:EntropyAck) class RecoveryDevice(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _RECOVERYDEVICE # @@protoc_insertion_point(class_scope:RecoveryDevice) class WordRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _WORDREQUEST # @@protoc_insertion_point(class_scope:WordRequest) class WordAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _WORDACK # @@protoc_insertion_point(class_scope:WordAck) class CharacterRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CHARACTERREQUEST # @@protoc_insertion_point(class_scope:CharacterRequest) class CharacterAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CHARACTERACK # @@protoc_insertion_point(class_scope:CharacterAck) class SignMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SIGNMESSAGE # @@protoc_insertion_point(class_scope:SignMessage) class VerifyMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _VERIFYMESSAGE # @@protoc_insertion_point(class_scope:VerifyMessage) class MessageSignature(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _MESSAGESIGNATURE # @@protoc_insertion_point(class_scope:MessageSignature) class EncryptMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ENCRYPTMESSAGE # @@protoc_insertion_point(class_scope:EncryptMessage) class EncryptedMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ENCRYPTEDMESSAGE # @@protoc_insertion_point(class_scope:EncryptedMessage) class DecryptMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DECRYPTMESSAGE # @@protoc_insertion_point(class_scope:DecryptMessage) class DecryptedMessage(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DECRYPTEDMESSAGE # @@protoc_insertion_point(class_scope:DecryptedMessage) class CipherKeyValue(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CIPHERKEYVALUE # @@protoc_insertion_point(class_scope:CipherKeyValue) class CipheredKeyValue(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _CIPHEREDKEYVALUE # @@protoc_insertion_point(class_scope:CipheredKeyValue) class EstimateTxSize(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _ESTIMATETXSIZE # @@protoc_insertion_point(class_scope:EstimateTxSize) class TxSize(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXSIZE # @@protoc_insertion_point(class_scope:TxSize) class SignTx(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SIGNTX # @@protoc_insertion_point(class_scope:SignTx) class SimpleSignTx(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SIMPLESIGNTX # @@protoc_insertion_point(class_scope:SimpleSignTx) class TxRequest(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXREQUEST # @@protoc_insertion_point(class_scope:TxRequest) class TxAck(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXACK # @@protoc_insertion_point(class_scope:TxAck) class SignIdentity(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SIGNIDENTITY # @@protoc_insertion_point(class_scope:SignIdentity) class SignedIdentity(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _SIGNEDIDENTITY # @@protoc_insertion_point(class_scope:SignedIdentity) class FirmwareErase(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _FIRMWAREERASE # @@protoc_insertion_point(class_scope:FirmwareErase) class FirmwareUpload(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _FIRMWAREUPLOAD # @@protoc_insertion_point(class_scope:FirmwareUpload) class DebugLinkDecision(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKDECISION # @@protoc_insertion_point(class_scope:DebugLinkDecision) class DebugLinkGetState(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKGETSTATE # @@protoc_insertion_point(class_scope:DebugLinkGetState) class DebugLinkState(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKSTATE # @@protoc_insertion_point(class_scope:DebugLinkState) class DebugLinkStop(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKSTOP # @@protoc_insertion_point(class_scope:DebugLinkStop) class DebugLinkLog(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKLOG # @@protoc_insertion_point(class_scope:DebugLinkLog) class DebugLinkFillConfig(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _DEBUGLINKFILLCONFIG # @@protoc_insertion_point(class_scope:DebugLinkFillConfig) DESCRIPTOR.has_options = True DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), '\n\033com.keepkey.device-protocolB\016KeepKeyMessage') _MESSAGETYPE.values_by_name["MessageType_Initialize"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Initialize"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Ping"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Ping"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Success"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Success"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Failure"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Failure"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ChangePin"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ChangePin"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_WipeDevice"].has_options = True _MESSAGETYPE.values_by_name["MessageType_WipeDevice"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_FirmwareErase"].has_options = True _MESSAGETYPE.values_by_name["MessageType_FirmwareErase"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_FirmwareUpload"].has_options = True _MESSAGETYPE.values_by_name["MessageType_FirmwareUpload"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_GetEntropy"].has_options = True _MESSAGETYPE.values_by_name["MessageType_GetEntropy"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Entropy"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Entropy"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_GetPublicKey"].has_options = True _MESSAGETYPE.values_by_name["MessageType_GetPublicKey"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_PublicKey"].has_options = True _MESSAGETYPE.values_by_name["MessageType_PublicKey"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_LoadDevice"].has_options = True _MESSAGETYPE.values_by_name["MessageType_LoadDevice"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ResetDevice"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ResetDevice"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_SignTx"].has_options = True _MESSAGETYPE.values_by_name["MessageType_SignTx"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_SimpleSignTx"].has_options = True _MESSAGETYPE.values_by_name["MessageType_SimpleSignTx"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Features"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Features"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_PinMatrixRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_PinMatrixRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_PinMatrixAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_PinMatrixAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Cancel"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Cancel"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_TxRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_TxRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_TxAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_TxAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_CipherKeyValue"].has_options = True _MESSAGETYPE.values_by_name["MessageType_CipherKeyValue"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ClearSession"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ClearSession"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ApplySettings"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ApplySettings"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ButtonRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ButtonRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_ButtonAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_ButtonAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_GetAddress"].has_options = True _MESSAGETYPE.values_by_name["MessageType_GetAddress"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_Address"].has_options = True _MESSAGETYPE.values_by_name["MessageType_Address"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_EntropyRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_EntropyRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_EntropyAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_EntropyAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_SignMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_SignMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_VerifyMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_VerifyMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_MessageSignature"].has_options = True _MESSAGETYPE.values_by_name["MessageType_MessageSignature"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_PassphraseRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_PassphraseRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_PassphraseAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_PassphraseAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_EstimateTxSize"].has_options = True _MESSAGETYPE.values_by_name["MessageType_EstimateTxSize"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_TxSize"].has_options = True _MESSAGETYPE.values_by_name["MessageType_TxSize"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_RecoveryDevice"].has_options = True _MESSAGETYPE.values_by_name["MessageType_RecoveryDevice"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_WordRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_WordRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_WordAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_WordAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_CipheredKeyValue"].has_options = True _MESSAGETYPE.values_by_name["MessageType_CipheredKeyValue"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_EncryptMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_EncryptMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_EncryptedMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_EncryptedMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DecryptMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DecryptMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DecryptedMessage"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DecryptedMessage"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_SignIdentity"].has_options = True _MESSAGETYPE.values_by_name["MessageType_SignIdentity"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_SignedIdentity"].has_options = True _MESSAGETYPE.values_by_name["MessageType_SignedIdentity"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_GetFeatures"].has_options = True _MESSAGETYPE.values_by_name["MessageType_GetFeatures"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_CharacterRequest"].has_options = True _MESSAGETYPE.values_by_name["MessageType_CharacterRequest"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\230\265\030\001') _MESSAGETYPE.values_by_name["MessageType_CharacterAck"].has_options = True _MESSAGETYPE.values_by_name["MessageType_CharacterAck"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\220\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkDecision"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkDecision"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkGetState"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkGetState"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkState"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkState"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkStop"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkStop"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\240\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkLog"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkLog"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001') _MESSAGETYPE.values_by_name["MessageType_DebugLinkFillConfig"].has_options = True _MESSAGETYPE.values_by_name["MessageType_DebugLinkFillConfig"]._options = _descriptor._ParseOptions(descriptor_pb2.EnumValueOptions(), '\250\265\030\001') # @@protoc_insertion_point(module_scope) keepkey-0.7.3/keepkeylib/protobuf_json.py0000644000076500000240000001173112717427115020777 0ustar darinstaff00000000000000# JSON serialization support for Google's protobuf Messages # Copyright (c) 2009, Paul Dovbush # All rights reserved. # http://code.google.com/p/protobuf-json/ # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ''' Provide serialization and de-serialization of Google's protobuf Messages into/from JSON format. ''' # groups are deprecated and not supported; # Note that preservation of unknown fields is currently not available for Python (c) google docs # extensions is not supported from 0.0.5 (due to gpb2.3 changes) __version__='0.0.5' __author__='Paul Dovbush ' import json from google.protobuf.descriptor import FieldDescriptor as FD import binascii import types_pb2 as types class ParseError(Exception): pass def json2pb(pb, js): ''' convert JSON string to google.protobuf.descriptor instance ''' for field in pb.DESCRIPTOR.fields: if field.name not in js: continue if field.type == FD.TYPE_MESSAGE: pass elif field.type in _js2ftype: ftype = _js2ftype[field.type] else: raise ParseError("Field %s.%s of type '%d' is not supported" % (pb.__class__.__name__, field.name, field.type, )) value = js[field.name] if field.label == FD.LABEL_REPEATED: pb_value = getattr(pb, field.name, None) for v in value: if field.type == FD.TYPE_MESSAGE: json2pb(pb_value.add(), v) else: pb_value.append(ftype(v)) else: if field.type == FD.TYPE_MESSAGE: json2pb(getattr(pb, field.name, None), value) else: setattr(pb, field.name, ftype(value)) return pb def pb2json(pb): ''' convert google.protobuf.descriptor instance to JSON string ''' js = {} # fields = pb.DESCRIPTOR.fields #all fields fields = pb.ListFields() #only filled (including extensions) for field,value in fields: if field.type == FD.TYPE_MESSAGE: ftype = pb2json elif field.type == FD.TYPE_ENUM: ftype = lambda x: field.enum_type.values[x].name elif field.type in _ftype2js: ftype = _ftype2js[field.type] else: raise ParseError("Field %s.%s of type '%d' is not supported" % (pb.__class__.__name__, field.name, field.type, )) if field.label == FD.LABEL_REPEATED: js_value = [] for v in value: js_value.append(ftype(v)) else: js_value = ftype(value) js[field.name] = js_value return js _ftype2js = { FD.TYPE_DOUBLE: float, FD.TYPE_FLOAT: float, FD.TYPE_INT64: long, FD.TYPE_UINT64: long, FD.TYPE_INT32: int, FD.TYPE_FIXED64: float, FD.TYPE_FIXED32: float, FD.TYPE_BOOL: bool, FD.TYPE_STRING: unicode, #FD.TYPE_MESSAGE handled specially FD.TYPE_BYTES: lambda x: binascii.hexlify(x), FD.TYPE_UINT32: int, # FD.TYPE_ENUM: handled specially FD.TYPE_SFIXED32: float, FD.TYPE_SFIXED64: float, FD.TYPE_SINT32: int, FD.TYPE_SINT64: long, } _js2ftype = { FD.TYPE_DOUBLE: float, FD.TYPE_FLOAT: float, FD.TYPE_INT64: long, FD.TYPE_UINT64: long, FD.TYPE_INT32: int, FD.TYPE_FIXED64: float, FD.TYPE_FIXED32: float, FD.TYPE_BOOL: bool, FD.TYPE_STRING: unicode, # FD.TYPE_MESSAGE handled specially FD.TYPE_BYTES: lambda x: binascii.unhexlify(x), FD.TYPE_UINT32: int, FD.TYPE_ENUM: lambda x: getattr(types, x), FD.TYPE_SFIXED32: float, FD.TYPE_SFIXED64: float, FD.TYPE_SINT32: int, FD.TYPE_SINT64: long, } keepkey-0.7.3/keepkeylib/qt/0000755000076500000240000000000012726077014016154 5ustar darinstaff00000000000000keepkey-0.7.3/keepkeylib/qt/__init__.py0000644000076500000240000000000012717427115020254 0ustar darinstaff00000000000000keepkey-0.7.3/keepkeylib/qt/pinmatrix.py0000644000076500000240000000712012726074236020544 0ustar darinstaff00000000000000from __future__ import print_function import sys import math import operator from PyQt4.QtGui import (QPushButton, QLineEdit, QSizePolicy, QRegExpValidator, QLabel, QApplication, QWidget, QGridLayout, QVBoxLayout, QHBoxLayout) from PyQt4.QtCore import QObject, SIGNAL, QRegExp, Qt class PinButton(QPushButton): def __init__(self, password, encoded_value): super(PinButton, self).__init__('?') self.password = password self.encoded_value = encoded_value QObject.connect(self, SIGNAL('clicked()'), self._pressed) def _pressed(self): self.password.setText(self.password.text() + str(self.encoded_value)) self.password.setFocus() class PinMatrixWidget(QWidget): ''' Displays widget with nine blank buttons and password box. Encodes button clicks into sequence of numbers for passing into PinAck messages of KeepKey. show_strength=True may be useful for entering new PIN ''' def __init__(self, show_strength=True, parent=None): super(PinMatrixWidget, self).__init__(parent) self.password = QLineEdit() self.password.setValidator(QRegExpValidator(QRegExp('[1-9]+'), None)) self.password.setEchoMode(QLineEdit.Password) QObject.connect(self.password, SIGNAL('textChanged(QString)'), self._password_changed) self.strength = QLabel() self.strength.setMinimumWidth(75) self.strength.setAlignment(Qt.AlignCenter) self._set_strength(0) grid = QGridLayout() grid.setSpacing(0) for y in range(3)[::-1]: for x in range(3): button = PinButton(self.password, x + y * 3 + 1) button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) button.setFocusPolicy(Qt.NoFocus) grid.addWidget(button, 3 - y, x) hbox = QHBoxLayout() hbox.addWidget(self.password) if show_strength: hbox.addWidget(self.strength) vbox = QVBoxLayout() vbox.addLayout(grid) vbox.addLayout(hbox) self.setLayout(vbox) def _set_strength(self, strength): if strength < 3000: self.strength.setText('weak') self.strength.setStyleSheet("QLabel { color : #d00; }") elif strength < 60000: self.strength.setText('fine') self.strength.setStyleSheet("QLabel { color : #db0; }") elif strength < 360000: self.strength.setText('strong') self.strength.setStyleSheet("QLabel { color : #0a0; }") else: self.strength.setText('ULTIMATE') self.strength.setStyleSheet("QLabel { color : #000; font-weight: bold;}") def _password_changed(self, password): self._set_strength(self.get_strength()) def get_strength(self): digits = len(set(str(self.password.text()))) strength = math.factorial(9) / math.factorial(9 - digits) return strength def get_value(self): return self.password.text() if __name__ == '__main__': ''' Demo application showing PinMatrix widget in action ''' a = QApplication(sys.argv) matrix = PinMatrixWidget() def clicked(): print("PinMatrix value is", matrix.get_value()) print("Possible button combinations:", matrix.get_strength()) sys.exit() ok = QPushButton('OK') QObject.connect(ok, SIGNAL('clicked()'), clicked) vbox = QVBoxLayout() vbox.addWidget(matrix) vbox.addWidget(ok) w = QWidget() w.setLayout(vbox) w.move(100, 100) w.show() a.exec_() keepkey-0.7.3/keepkeylib/tools.py0000644000076500000240000000576012726074236017255 0ustar darinstaff00000000000000import hashlib import binascii import sys Hash = lambda x: hashlib.sha256(hashlib.sha256(x).digest()).digest() def hash_160(public_key): md = hashlib.new('ripemd160') md.update(hashlib.sha256(public_key).digest()) return md.digest() def hash_160_to_bc_address(h160, address_type): vh160 = chr(address_type) + h160 h = Hash(vh160) addr = vh160 + h[0:4] return b58encode(addr) def compress_pubkey(public_key): if public_key[0] == '\x04': return chr((ord(public_key[64]) & 1) + 2) + public_key[1:33] raise Exception("Pubkey is already compressed") def public_key_to_bc_address(public_key, address_type, compress=True): if public_key[0] == '\x04' and compress: public_key = compress_pubkey(public_key) h160 = hash_160(public_key) return hash_160_to_bc_address(h160, address_type) __b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' __b58base = len(__b58chars) def b58encode(v): """ encode v, which is a string of bytes, to base58.""" long_value = 0 for (i, c) in enumerate(v[::-1]): long_value += (256 ** i) * ord(c) result = '' while long_value >= __b58base: div, mod = divmod(long_value, __b58base) result = __b58chars[mod] + result long_value = div result = __b58chars[long_value] + result # Bitcoin does a little leading-zero-compression: # leading 0-bytes in the input become leading-1s nPad = 0 for c in v: if c == '\0': nPad += 1 else: break return (__b58chars[0] * nPad) + result def b58decode(v, length): """ decode v into a string of len bytes.""" long_value = 0 for (i, c) in enumerate(v[::-1]): long_value += __b58chars.find(c) * (__b58base ** i) result = '' while long_value >= 256: div, mod = divmod(long_value, 256) result = chr(mod) + result long_value = div result = chr(long_value) + result nPad = 0 for c in v: if c == __b58chars[0]: nPad += 1 else: break result = chr(0) * nPad + result if length is not None and len(result) != length: return None if sys.version_info[0] < 3: return result else: return str.encode(result) def monkeypatch_google_protobuf_text_format(): # monkeypatching: text formatting of protobuf messages import google.protobuf.text_format import google.protobuf.descriptor _oldPrintFieldValue = google.protobuf.text_format.PrintFieldValue def _customPrintFieldValue(field, value, out, indent=0, as_utf8=False, as_one_line=False, pointy_brackets=False, float_format=None): if field.type == google.protobuf.descriptor.FieldDescriptor.TYPE_BYTES: _oldPrintFieldValue(field, 'hex(%s)' % binascii.hexlify(value), out, indent, as_utf8, as_one_line) else: _oldPrintFieldValue(field, value, out, indent, as_utf8, as_one_line) google.protobuf.text_format.PrintFieldValue = _customPrintFieldValue keepkey-0.7.3/keepkeylib/transport.py0000644000076500000240000001012112726074236020134 0ustar darinstaff00000000000000import struct from . import mapping class NotImplementedException(Exception): pass class ConnectionError(Exception): pass class Transport(object): def __init__(self, device, *args, **kwargs): self.device = device self.session_depth = 0 self._open() def _open(self): raise NotImplementedException("Not implemented") def _close(self): raise NotImplementedException("Not implemented") def _write(self, msg, protobuf_msg): raise NotImplementedException("Not implemented") def _read(self): raise NotImplementedException("Not implemented") def _session_begin(self): pass def _session_end(self): pass def ready_to_read(self): """ Returns True if there is data to be read from the transport. Otherwise, False. """ raise NotImplementedException("Not implemented") def session_begin(self): """ Apply a lock to the device in order to preform synchronous multistep "conversations" with the device. For example, before entering the transaction signing workflow, one begins a session. After the transaction is complete, the session may be ended. """ if self.session_depth == 0: self._session_begin() self.session_depth += 1 def session_end(self): """ End a session. Se session_begin for an in depth description of TREZOR sessions. """ self.session_depth -= 1 self.session_depth = max(0, self.session_depth) if self.session_depth == 0: self._session_end() def close(self): """ Close the connection to the physical device or file descriptor represented by the Transport. """ self._close() def write(self, msg): """ Write mesage to tansport. msg should be a member of a valid `protobuf class `_ with a SerializeToString() method. """ ser = msg.SerializeToString() header = struct.pack(">HL", mapping.get_type(msg), len(ser)) self._write(b"##" + header + ser, msg) def read(self): """ If there is data available to be read from the transport, reads the data and tries to parse it as a protobuf message. If the parsing succeeds, return a protobuf object. Otherwise, returns None. """ if not self.ready_to_read(): return None data = self._read() if data is None: return None return self._parse_message(data) def read_blocking(self): """ Same as read, except blocks untill data is available to be read. """ while True: data = self._read() if data != None: break return self._parse_message(data) def _parse_message(self, data): (msg_type, data) = data if msg_type == 'protobuf': return data else: inst = mapping.get_class(msg_type)() inst.ParseFromString(data) return inst def _read_headers(self, read_f): # Try to read headers until some sane value are detected is_ok = False while not is_ok: # Align cursor to the beginning of the header ("##") c = read_f.read(1) i = 0 while c != b"#": i += 1 if i >= 64: # timeout raise Exception("Timed out while waiting for the magic character") c = read_f.read(1) if read_f.read(1) != b"#": # Second character must be # to be valid header raise Exception("Second magic character is broken") # Now we're most likely on the beginning of the header try: headerlen = struct.calcsize(">HL") (msg_type, datalen) = struct.unpack(">HL", read_f.read(headerlen)) break except: raise Exception("Cannot parse header length") return (msg_type, datalen) keepkey-0.7.3/keepkeylib/transport_fake.py0000644000076500000240000000112112726074236021122 0ustar darinstaff00000000000000'''FakeTransport implements dummy interface for Transport.''' # Local serial port loopback: socat PTY,link=COM8 PTY,link=COM9 from .transport import Transport, NotImplementedException class FakeTransport(Transport): def __init__(self, device, *args, **kwargs): super(FakeTransport, self).__init__(device, *args, **kwargs) def _open(self): pass def _close(self): pass def ready_to_read(self): return False def _write(self, msg, protobuf_msg): pass def _read(self): raise NotImplementedException("Not implemented") keepkey-0.7.3/keepkeylib/transport_hid.py0000644000076500000240000000715512726074236020775 0ustar darinstaff00000000000000'''USB HID implementation of Transport.''' import hid import time from .transport import Transport, ConnectionError DEVICE_IDS = [ (0x2B24, 0x0001), # KeepKey ] class FakeRead(object): # Let's pretend we have a file-like interface def __init__(self, func): self.func = func def read(self, size): return self.func(size) class HidTransport(Transport): def __init__(self, device, *args, **kwargs): self.hid = None self.buffer = '' # self.read_timeout = kwargs.get('read_timeout') device = device[int(bool(kwargs.get('debug_link')))] super(HidTransport, self).__init__(device, *args, **kwargs) @classmethod def enumerate(cls): """ Return a list of available TREZOR devices. """ devices = {} for d in hid.enumerate(0, 0): vendor_id = d['vendor_id'] product_id = d['product_id'] serial_number = d['serial_number'] interface_number = d['interface_number'] path = d['path'] # HIDAPI on Mac cannot detect correct HID interfaces, so device with # DebugLink doesn't work on Mac... if devices.get(serial_number) != None and devices[serial_number][0] == path: raise Exception("Two devices with the same path and S/N found. This is Mac, right? :-/") if (vendor_id, product_id) in DEVICE_IDS: devices.setdefault(serial_number, [None, None]) if interface_number == 0 or interface_number == -1: # normal link devices[serial_number][0] = path elif interface_number == 1: # debug link devices[serial_number][1] = path else: raise Exception("Unknown USB interface number: %d" % interface_number) # List of two-tuples (path_normal, path_debuglink) return list(devices.values()) def is_connected(self): """ Check if the device is still connected. """ for d in hid.enumerate(0, 0): if d['path'] == self.device: return True return False def _open(self): self.buffer = bytearray() self.hid = hid.device() self.hid.open_path(self.device) self.hid.set_nonblocking(True) # the following was needed just for TREZOR Shield # self.hid.send_feature_report([0x41, 0x01]) # enable UART # self.hid.send_feature_report([0x43, 0x03]) # purge TX/RX FIFOs def _close(self): self.hid.close() self.buffer = bytearray() self.hid = None def ready_to_read(self): return False def _write(self, msg, protobuf_msg): msg = bytearray(msg) while len(msg): # Report ID, data padded to 63 bytes self.hid.write([63, ] + list(msg[:63]) + [0] * (63 - len(msg[:63]))) msg = msg[63:] def _read(self): (msg_type, datalen) = self._read_headers(FakeRead(self._raw_read)) return (msg_type, self._raw_read(datalen)) def _raw_read(self, length): start = time.time() while len(self.buffer) < length: data = self.hid.read(64) if not len(data): time.sleep(0.001) continue report_id = data[0] if report_id > 63: # Command report raise Exception("Not implemented") # Payload received, skip the report ID self.buffer.extend(bytearray(data[1:])) ret = self.buffer[:length] self.buffer = self.buffer[length:] return bytes(ret) keepkey-0.7.3/keepkeylib/transport_pipe.py0000644000076500000240000000370212726074236021160 0ustar darinstaff00000000000000from __future__ import print_function import os from select import select from .transport import Transport """PipeTransport implements fake wire transport over local named pipe. Use this transport for talking with trezor simulator.""" class PipeTransport(Transport): def __init__(self, device, is_device, *args, **kwargs): self.is_device = is_device # Set True if act as device super(PipeTransport, self).__init__(device, *args, **kwargs) def _open(self): if self.is_device: self.filename_read = self.device+'.to' self.filename_write = self.device+'.from' os.mkfifo(self.filename_read, 0o600) os.mkfifo(self.filename_write, 0o600) else: self.filename_read = self.device+'.from' self.filename_write = self.device+'.to' if not os.path.exists(self.filename_write): raise Exception("Not connected") self.write_fd = os.open(self.filename_write, os.O_RDWR)#|os.O_NONBLOCK) self.write_f = os.fdopen(self.write_fd, 'w+b', 0) self.read_fd = os.open(self.filename_read, os.O_RDWR)#|os.O_NONBLOCK) self.read_f = os.fdopen(self.read_fd, 'rb', 0) def _close(self): self.read_f.close() self.write_f.close() if self.is_device: os.unlink(self.filename_read) os.unlink(self.filename_write) def ready_to_read(self): rlist, _, _ = select([self.read_f], [], [], 0) return len(rlist) > 0 def _write(self, msg, protobuf_msg): try: self.write_f.write(msg) self.write_f.flush() except OSError: print("Error while writing to socket") raise def _read(self): try: (msg_type, datalen) = self._read_headers(self.read_f) return (msg_type, self.read_f.read(datalen)) except IOError: print("Failed to read from device") raise keepkey-0.7.3/keepkeylib/transport_serial.py0000644000076500000240000000233612726074236021504 0ustar darinstaff00000000000000from __future__ import print_function '''SerialTransport implements wire transport over serial port.''' # Local serial port loopback: socat PTY,link=COM8 PTY,link=COM9 from select import select import serial from select import select from .transport import Transport class SerialTransport(Transport): def __init__(self, device, *args, **kwargs): self.serial = None super(SerialTransport, self).__init__(device, *args, **kwargs) def _open(self): self.serial = serial.Serial(self.device, 115200, timeout=10, writeTimeout=10) def _close(self): self.serial.close() self.serial = None def ready_to_read(self): rlist, _, _ = select([self.serial], [], [], 0) return len(rlist) > 0 def _write(self, msg, protobuf_msg): try: self.serial.write(msg) self.serial.flush() except serial.SerialException: print("Error while writing to socket") raise def _read(self): try: (msg_type, datalen) = self._read_headers(self.serial) return (msg_type, self.serial.read(datalen)) except serial.SerialException: print("Failed to read from device") raise keepkey-0.7.3/keepkeylib/transport_socket.py0000644000076500000240000000660212726074236021515 0ustar darinstaff00000000000000from __future__ import print_function '''SocketTransport implements TCP socket interface for Transport.''' import socket from select import select from .transport import Transport class SocketTransportClient(Transport): def __init__(self, device, *args, **kwargs): device = device.split(':') if len(device) < 2: device = ('0.0.0.0', int(device[0])) else: device = (device[0], int(device[1])) self.socket = None super(SocketTransportClient, self).__init__(device, *args, **kwargs) def _open(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.connect(self.device) self.filelike = self.socket.makefile() def _close(self): self.socket.close() self.socket = None self.filelike = None def ready_to_read(self): rlist, _, _ = select([self.socket], [], [], 0) return len(rlist) > 0 def _write(self, msg, protobuf_msg): self.socket.sendall(msg) def _read(self): try: (msg_type, datalen) = self._read_headers(self.filelike) return (msg_type, self.filelike.read(datalen)) except socket.error: print("Failed to read from device") return None class SocketTransport(Transport): def __init__(self, device, *args, **kwargs): device = device.split(':') if len(device) < 2: device = ('0.0.0.0', int(device[0])) else: device = (device[0], int(device[1])) self.socket = None self.client = None self.filelike = None super(SocketTransport, self).__init__(device, *args, **kwargs) def _open(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #self.socket.setblocking(0) self.socket.bind(self.device) self.socket.listen(5) def _disconnect_client(self): print("Disconnecting client") if self.client != None: self.client.close() self.client = None self.filelike = None def _close(self): self._disconnect_client() self.socket.close() self.socket = None def ready_to_read(self): if self.filelike: # Connected rlist, _, _ = select([self.client], [], [], 0) return len(rlist) > 0 else: # Waiting for connection rlist, _, _ = select([self.socket], [], [], 0) if len(rlist) > 0: (self.client, ipaddr) = self.socket.accept() print("Connected", ipaddr[0]) self.filelike = self.client.makefile() return self.ready_to_read() return False def _write(self, msg, protobuf_msg): if self.filelike: # None on disconnected client try: self.filelike.write(msg) self.filelike.flush() except socket.error: print("Socket error") self._disconnect_client() def _read(self): try: (msg_type, datalen) = self._read_headers(self.filelike) return (msg_type, self.filelike.read(datalen)) except Exception: print("Failed to read from device") self._disconnect_client() return None keepkey-0.7.3/keepkeylib/tx_api.py0000644000076500000240000000536512726074236017402 0ustar darinstaff00000000000000import binascii from decimal import Decimal # from filecache import filecache, DAY import requests from . import types_pb2 as proto_types def fetch_json(url): try: r = requests.get(url, headers={'User-agent': 'Mozilla/5.0'}) return r.json() except: raise Exception('URL error: %s' % url) def insight_tx(url, rawdata=False): if not rawdata: data = fetch_json(url) else: data = url t = proto_types.TransactionType() t.version = data['version'] t.lock_time = data['locktime'] for vin in data['vin']: i = t.inputs.add() if 'coinbase' in vin.keys(): i.prev_hash = "\0"*32 i.prev_index = 0xffffffff # signed int -1 i.script_sig = binascii.unhexlify(vin['coinbase']) i.sequence = vin['sequence'] else: i.prev_hash = binascii.unhexlify(vin['txid']) i.prev_index = vin['vout'] i.script_sig = binascii.unhexlify(vin['scriptSig']['hex']) i.sequence = vin['sequence'] for vout in data['vout']: o = t.bin_outputs.add() o.amount = int(Decimal(str(vout['value'])) * 100000000) o.script_pubkey = binascii.unhexlify(vout['scriptPubKey']['hex']) return t def smartbit_tx(url, rawdata=False): if not rawdata: data = fetch_json(url) else: data = url data = data['transaction'] t = proto_types.TransactionType() t.version = int(data['version']) t.lock_time = data['locktime'] for vin in data['inputs']: i = t.inputs.add() if 'coinbase' in vin.keys(): i.prev_hash = "\0"*32 i.prev_index = 0xffffffff # signed int -1 i.script_sig = binascii.unhexlify(vin['coinbase']) i.sequence = vin['sequence'] else: i.prev_hash = binascii.unhexlify(vin['txid']) i.prev_index = vin['vout'] i.script_sig = binascii.unhexlify(vin['script_sig']['hex']) i.sequence = vin['sequence'] for vout in data['outputs']: o = t.bin_outputs.add() o.amount = int(Decimal(vout['value']) * 100000000) o.script_pubkey = binascii.unhexlify(vout['script_pub_key']['hex']) return t class TXAPIBitcoin(object): # @filecache(DAY) def get_tx(self, txhash): url = 'https://insight.bitpay.com/api/tx/%s' % txhash return insight_tx(url) class TXAPITestnet(object): # @filecache(DAY) def get_tx(self, txhash): url = 'https://test-insight.bitpay.com/api/tx/%s' % txhash return insight_tx(url) class TXAPISegnet(object): # @filecache(DAY) def get_tx(self, txhash): url = 'https://segnet-api.smartbit.com.au/v1/blockchain/tx/%s' % txhash return smartbit_tx(url) keepkey-0.7.3/keepkeylib/types_pb2.py0000644000076500000240000012451512726074236020024 0ustar darinstaff00000000000000# Generated by the protocol buffer compiler. DO NOT EDIT! # source: types.proto from google.protobuf.internal import enum_type_wrapper from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import descriptor_pb2 # @@protoc_insertion_point(imports) import google.protobuf.descriptor_pb2 DESCRIPTOR = _descriptor.FileDescriptor( name='types.proto', package='', serialized_pb='\n\x0btypes.proto\x1a google/protobuf/descriptor.proto\"\x80\x01\n\nHDNodeType\x12\r\n\x05\x64\x65pth\x18\x01 \x02(\r\x12\x13\n\x0b\x66ingerprint\x18\x02 \x02(\r\x12\x11\n\tchild_num\x18\x03 \x02(\r\x12\x12\n\nchain_code\x18\x04 \x02(\x0c\x12\x13\n\x0bprivate_key\x18\x05 \x01(\x0c\x12\x12\n\npublic_key\x18\x06 \x01(\x0c\">\n\x0eHDNodePathType\x12\x19\n\x04node\x18\x01 \x02(\x0b\x32\x0b.HDNodeType\x12\x11\n\taddress_n\x18\x02 \x03(\r\"~\n\x08\x43oinType\x12\x11\n\tcoin_name\x18\x01 \x01(\t\x12\x15\n\rcoin_shortcut\x18\x02 \x01(\t\x12\x17\n\x0c\x61\x64\x64ress_type\x18\x03 \x01(\r:\x01\x30\x12\x11\n\tmaxfee_kb\x18\x04 \x01(\x04\x12\x1c\n\x11\x61\x64\x64ress_type_p2sh\x18\x05 \x01(\r:\x01\x35\"[\n\x18MultisigRedeemScriptType\x12 \n\x07pubkeys\x18\x01 \x03(\x0b\x32\x0f.HDNodePathType\x12\x12\n\nsignatures\x18\x02 \x03(\x0c\x12\t\n\x01m\x18\x03 \x01(\r\"\xdb\x01\n\x0bTxInputType\x12\x11\n\taddress_n\x18\x01 \x03(\r\x12\x11\n\tprev_hash\x18\x02 \x02(\x0c\x12\x12\n\nprev_index\x18\x03 \x02(\r\x12\x12\n\nscript_sig\x18\x04 \x01(\x0c\x12\x1c\n\x08sequence\x18\x05 \x01(\r:\n4294967295\x12\x33\n\x0bscript_type\x18\x06 \x01(\x0e\x32\x10.InputScriptType:\x0cSPENDADDRESS\x12+\n\x08multisig\x18\x07 \x01(\x0b\x32\x19.MultisigRedeemScriptType\"\xd9\x01\n\x0cTxOutputType\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x11\n\taddress_n\x18\x02 \x03(\r\x12\x0e\n\x06\x61mount\x18\x03 \x02(\x04\x12&\n\x0bscript_type\x18\x04 \x02(\x0e\x32\x11.OutputScriptType\x12+\n\x08multisig\x18\x05 \x01(\x0b\x32\x19.MultisigRedeemScriptType\x12\x16\n\x0eop_return_data\x18\x06 \x01(\x0c\x12(\n\x0c\x61\x64\x64ress_type\x18\x07 \x01(\x0e\x32\x12.OutputAddressType\"8\n\x0fTxOutputBinType\x12\x0e\n\x06\x61mount\x18\x01 \x02(\x04\x12\x15\n\rscript_pubkey\x18\x02 \x02(\x0c\"\xc3\x01\n\x0fTransactionType\x12\x0f\n\x07version\x18\x01 \x01(\r\x12\x1c\n\x06inputs\x18\x02 \x03(\x0b\x32\x0c.TxInputType\x12%\n\x0b\x62in_outputs\x18\x03 \x03(\x0b\x32\x10.TxOutputBinType\x12\x1e\n\x07outputs\x18\x05 \x03(\x0b\x32\r.TxOutputType\x12\x11\n\tlock_time\x18\x04 \x01(\r\x12\x12\n\ninputs_cnt\x18\x06 \x01(\r\x12\x13\n\x0boutputs_cnt\x18\x07 \x01(\r\">\n\x14TxRequestDetailsType\x12\x15\n\rrequest_index\x18\x01 \x01(\r\x12\x0f\n\x07tx_hash\x18\x02 \x01(\x0c\"\\\n\x17TxRequestSerializedType\x12\x17\n\x0fsignature_index\x18\x01 \x01(\r\x12\x11\n\tsignature\x18\x02 \x01(\x0c\x12\x15\n\rserialized_tx\x18\x03 \x01(\x0c\"g\n\x0cIdentityType\x12\r\n\x05proto\x18\x01 \x01(\t\x12\x0c\n\x04user\x18\x02 \x01(\t\x12\x0c\n\x04host\x18\x03 \x01(\t\x12\x0c\n\x04port\x18\x04 \x01(\t\x12\x0c\n\x04path\x18\x05 \x01(\t\x12\x10\n\x05index\x18\x06 \x01(\r:\x01\x30*\xcd\x02\n\x0b\x46\x61ilureType\x12\x1d\n\x19\x46\x61ilure_UnexpectedMessage\x10\x01\x12\x1a\n\x16\x46\x61ilure_ButtonExpected\x10\x02\x12\x17\n\x13\x46\x61ilure_SyntaxError\x10\x03\x12\x1b\n\x17\x46\x61ilure_ActionCancelled\x10\x04\x12\x17\n\x13\x46\x61ilure_PinExpected\x10\x05\x12\x18\n\x14\x46\x61ilure_PinCancelled\x10\x06\x12\x16\n\x12\x46\x61ilure_PinInvalid\x10\x07\x12\x1c\n\x18\x46\x61ilure_InvalidSignature\x10\x08\x12\x11\n\rFailure_Other\x10\t\x12\x1a\n\x16\x46\x61ilure_NotEnoughFunds\x10\n\x12\x1a\n\x16\x46\x61ilure_NotInitialized\x10\x0b\x12\x19\n\x15\x46\x61ilure_FirmwareError\x10\x63*_\n\x10OutputScriptType\x12\x10\n\x0cPAYTOADDRESS\x10\x00\x12\x13\n\x0fPAYTOSCRIPTHASH\x10\x01\x12\x11\n\rPAYTOMULTISIG\x10\x02\x12\x11\n\rPAYTOOPRETURN\x10\x03*6\n\x0fInputScriptType\x12\x10\n\x0cSPENDADDRESS\x10\x00\x12\x11\n\rSPENDMULTISIG\x10\x01*D\n\x0bRequestType\x12\x0b\n\x07TXINPUT\x10\x00\x12\x0c\n\x08TXOUTPUT\x10\x01\x12\n\n\x06TXMETA\x10\x02\x12\x0e\n\nTXFINISHED\x10\x03*8\n\x11OutputAddressType\x12\t\n\x05SPEND\x10\x00\x12\x0c\n\x08TRANSFER\x10\x01\x12\n\n\x06\x43HANGE\x10\x02*\xb0\x07\n\x11\x42uttonRequestType\x12\x17\n\x13\x42uttonRequest_Other\x10\x01\x12\"\n\x1e\x42uttonRequest_FeeOverThreshold\x10\x02\x12\x1f\n\x1b\x42uttonRequest_ConfirmOutput\x10\x03\x12\x1d\n\x19\x42uttonRequest_ResetDevice\x10\x04\x12\x1d\n\x19\x42uttonRequest_ConfirmWord\x10\x05\x12\x1c\n\x18\x42uttonRequest_WipeDevice\x10\x06\x12\x1d\n\x19\x42uttonRequest_ProtectCall\x10\x07\x12\x18\n\x14\x42uttonRequest_SignTx\x10\x08\x12\x1f\n\x1b\x42uttonRequest_FirmwareCheck\x10\t\x12\x19\n\x15\x42uttonRequest_Address\x10\n\x12\x1f\n\x1b\x42uttonRequest_FirmwareErase\x10\x0b\x12*\n&ButtonRequest_ConfirmTransferToAccount\x10\x0c\x12+\n\'ButtonRequest_ConfirmTransferToNodePath\x10\r\x12\x1d\n\x19\x42uttonRequest_ChangeLabel\x10\x0e\x12 \n\x1c\x42uttonRequest_ChangeLanguage\x10\x0f\x12\"\n\x1e\x42uttonRequest_EnablePassphrase\x10\x10\x12#\n\x1f\x42uttonRequest_DisablePassphrase\x10\x11\x12\'\n#ButtonRequest_EncryptAndSignMessage\x10\x12\x12 \n\x1c\x42uttonRequest_EncryptMessage\x10\x13\x12\"\n\x1e\x42uttonRequest_ImportPrivateKey\x10\x14\x12(\n$ButtonRequest_ImportRecoverySentence\x10\x15\x12\x1e\n\x1a\x42uttonRequest_signIdentity\x10\x16\x12\x16\n\x12\x42uttonRequest_Ping\x10\x17\x12\x1b\n\x17\x42uttonRequest_RemovePIN\x10\x18\x12\x1b\n\x17\x42uttonRequest_ChangePIN\x10\x19\x12\x1b\n\x17\x42uttonRequest_CreatePIN\x10\x1a\x12!\n\x1d\x42uttonRequest_GenerateEntropy\x10\x1b\x12\x1d\n\x19\x42uttonRequest_SignMessage\x10\x1c*\x7f\n\x14PinMatrixRequestType\x12 \n\x1cPinMatrixRequestType_Current\x10\x01\x12!\n\x1dPinMatrixRequestType_NewFirst\x10\x02\x12\"\n\x1ePinMatrixRequestType_NewSecond\x10\x03:4\n\x07wire_in\x12!.google.protobuf.EnumValueOptions\x18\xd2\x86\x03 \x01(\x08:5\n\x08wire_out\x12!.google.protobuf.EnumValueOptions\x18\xd3\x86\x03 \x01(\x08::\n\rwire_debug_in\x12!.google.protobuf.EnumValueOptions\x18\xd4\x86\x03 \x01(\x08:;\n\x0ewire_debug_out\x12!.google.protobuf.EnumValueOptions\x18\xd5\x86\x03 \x01(\x08\x42*\n\x1b\x63om.keepkey.device-protocolB\x0bKeepKeyType') _FAILURETYPE = _descriptor.EnumDescriptor( name='FailureType', full_name='FailureType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='Failure_UnexpectedMessage', index=0, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_ButtonExpected', index=1, number=2, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_SyntaxError', index=2, number=3, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_ActionCancelled', index=3, number=4, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_PinExpected', index=4, number=5, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_PinCancelled', index=5, number=6, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_PinInvalid', index=6, number=7, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_InvalidSignature', index=7, number=8, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_Other', index=8, number=9, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_NotEnoughFunds', index=9, number=10, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_NotInitialized', index=10, number=11, options=None, type=None), _descriptor.EnumValueDescriptor( name='Failure_FirmwareError', index=11, number=99, options=None, type=None), ], containing_type=None, options=None, serialized_start=1427, serialized_end=1760, ) FailureType = enum_type_wrapper.EnumTypeWrapper(_FAILURETYPE) _OUTPUTSCRIPTTYPE = _descriptor.EnumDescriptor( name='OutputScriptType', full_name='OutputScriptType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='PAYTOADDRESS', index=0, number=0, options=None, type=None), _descriptor.EnumValueDescriptor( name='PAYTOSCRIPTHASH', index=1, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='PAYTOMULTISIG', index=2, number=2, options=None, type=None), _descriptor.EnumValueDescriptor( name='PAYTOOPRETURN', index=3, number=3, options=None, type=None), ], containing_type=None, options=None, serialized_start=1762, serialized_end=1857, ) OutputScriptType = enum_type_wrapper.EnumTypeWrapper(_OUTPUTSCRIPTTYPE) _INPUTSCRIPTTYPE = _descriptor.EnumDescriptor( name='InputScriptType', full_name='InputScriptType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='SPENDADDRESS', index=0, number=0, options=None, type=None), _descriptor.EnumValueDescriptor( name='SPENDMULTISIG', index=1, number=1, options=None, type=None), ], containing_type=None, options=None, serialized_start=1859, serialized_end=1913, ) InputScriptType = enum_type_wrapper.EnumTypeWrapper(_INPUTSCRIPTTYPE) _REQUESTTYPE = _descriptor.EnumDescriptor( name='RequestType', full_name='RequestType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='TXINPUT', index=0, number=0, options=None, type=None), _descriptor.EnumValueDescriptor( name='TXOUTPUT', index=1, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='TXMETA', index=2, number=2, options=None, type=None), _descriptor.EnumValueDescriptor( name='TXFINISHED', index=3, number=3, options=None, type=None), ], containing_type=None, options=None, serialized_start=1915, serialized_end=1983, ) RequestType = enum_type_wrapper.EnumTypeWrapper(_REQUESTTYPE) _OUTPUTADDRESSTYPE = _descriptor.EnumDescriptor( name='OutputAddressType', full_name='OutputAddressType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='SPEND', index=0, number=0, options=None, type=None), _descriptor.EnumValueDescriptor( name='TRANSFER', index=1, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='CHANGE', index=2, number=2, options=None, type=None), ], containing_type=None, options=None, serialized_start=1985, serialized_end=2041, ) OutputAddressType = enum_type_wrapper.EnumTypeWrapper(_OUTPUTADDRESSTYPE) _BUTTONREQUESTTYPE = _descriptor.EnumDescriptor( name='ButtonRequestType', full_name='ButtonRequestType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='ButtonRequest_Other', index=0, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_FeeOverThreshold', index=1, number=2, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ConfirmOutput', index=2, number=3, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ResetDevice', index=3, number=4, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ConfirmWord', index=4, number=5, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_WipeDevice', index=5, number=6, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ProtectCall', index=6, number=7, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_SignTx', index=7, number=8, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_FirmwareCheck', index=8, number=9, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_Address', index=9, number=10, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_FirmwareErase', index=10, number=11, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ConfirmTransferToAccount', index=11, number=12, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ConfirmTransferToNodePath', index=12, number=13, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ChangeLabel', index=13, number=14, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ChangeLanguage', index=14, number=15, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_EnablePassphrase', index=15, number=16, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_DisablePassphrase', index=16, number=17, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_EncryptAndSignMessage', index=17, number=18, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_EncryptMessage', index=18, number=19, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ImportPrivateKey', index=19, number=20, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ImportRecoverySentence', index=20, number=21, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_signIdentity', index=21, number=22, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_Ping', index=22, number=23, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_RemovePIN', index=23, number=24, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_ChangePIN', index=24, number=25, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_CreatePIN', index=25, number=26, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_GenerateEntropy', index=26, number=27, options=None, type=None), _descriptor.EnumValueDescriptor( name='ButtonRequest_SignMessage', index=27, number=28, options=None, type=None), ], containing_type=None, options=None, serialized_start=2044, serialized_end=2988, ) ButtonRequestType = enum_type_wrapper.EnumTypeWrapper(_BUTTONREQUESTTYPE) _PINMATRIXREQUESTTYPE = _descriptor.EnumDescriptor( name='PinMatrixRequestType', full_name='PinMatrixRequestType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='PinMatrixRequestType_Current', index=0, number=1, options=None, type=None), _descriptor.EnumValueDescriptor( name='PinMatrixRequestType_NewFirst', index=1, number=2, options=None, type=None), _descriptor.EnumValueDescriptor( name='PinMatrixRequestType_NewSecond', index=2, number=3, options=None, type=None), ], containing_type=None, options=None, serialized_start=2990, serialized_end=3117, ) PinMatrixRequestType = enum_type_wrapper.EnumTypeWrapper(_PINMATRIXREQUESTTYPE) Failure_UnexpectedMessage = 1 Failure_ButtonExpected = 2 Failure_SyntaxError = 3 Failure_ActionCancelled = 4 Failure_PinExpected = 5 Failure_PinCancelled = 6 Failure_PinInvalid = 7 Failure_InvalidSignature = 8 Failure_Other = 9 Failure_NotEnoughFunds = 10 Failure_NotInitialized = 11 Failure_FirmwareError = 99 PAYTOADDRESS = 0 PAYTOSCRIPTHASH = 1 PAYTOMULTISIG = 2 PAYTOOPRETURN = 3 SPENDADDRESS = 0 SPENDMULTISIG = 1 TXINPUT = 0 TXOUTPUT = 1 TXMETA = 2 TXFINISHED = 3 SPEND = 0 TRANSFER = 1 CHANGE = 2 ButtonRequest_Other = 1 ButtonRequest_FeeOverThreshold = 2 ButtonRequest_ConfirmOutput = 3 ButtonRequest_ResetDevice = 4 ButtonRequest_ConfirmWord = 5 ButtonRequest_WipeDevice = 6 ButtonRequest_ProtectCall = 7 ButtonRequest_SignTx = 8 ButtonRequest_FirmwareCheck = 9 ButtonRequest_Address = 10 ButtonRequest_FirmwareErase = 11 ButtonRequest_ConfirmTransferToAccount = 12 ButtonRequest_ConfirmTransferToNodePath = 13 ButtonRequest_ChangeLabel = 14 ButtonRequest_ChangeLanguage = 15 ButtonRequest_EnablePassphrase = 16 ButtonRequest_DisablePassphrase = 17 ButtonRequest_EncryptAndSignMessage = 18 ButtonRequest_EncryptMessage = 19 ButtonRequest_ImportPrivateKey = 20 ButtonRequest_ImportRecoverySentence = 21 ButtonRequest_signIdentity = 22 ButtonRequest_Ping = 23 ButtonRequest_RemovePIN = 24 ButtonRequest_ChangePIN = 25 ButtonRequest_CreatePIN = 26 ButtonRequest_GenerateEntropy = 27 ButtonRequest_SignMessage = 28 PinMatrixRequestType_Current = 1 PinMatrixRequestType_NewFirst = 2 PinMatrixRequestType_NewSecond = 3 WIRE_IN_FIELD_NUMBER = 60002 wire_in = _descriptor.FieldDescriptor( name='wire_in', full_name='wire_in', index=0, number=60002, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=True, extension_scope=None, options=None) WIRE_OUT_FIELD_NUMBER = 60003 wire_out = _descriptor.FieldDescriptor( name='wire_out', full_name='wire_out', index=1, number=60003, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=True, extension_scope=None, options=None) WIRE_DEBUG_IN_FIELD_NUMBER = 60004 wire_debug_in = _descriptor.FieldDescriptor( name='wire_debug_in', full_name='wire_debug_in', index=2, number=60004, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=True, extension_scope=None, options=None) WIRE_DEBUG_OUT_FIELD_NUMBER = 60005 wire_debug_out = _descriptor.FieldDescriptor( name='wire_debug_out', full_name='wire_debug_out', index=3, number=60005, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=True, extension_scope=None, options=None) _HDNODETYPE = _descriptor.Descriptor( name='HDNodeType', full_name='HDNodeType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='depth', full_name='HDNodeType.depth', index=0, number=1, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='fingerprint', full_name='HDNodeType.fingerprint', index=1, number=2, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='child_num', full_name='HDNodeType.child_num', index=2, number=3, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='chain_code', full_name='HDNodeType.chain_code', index=3, number=4, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='private_key', full_name='HDNodeType.private_key', index=4, number=5, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='public_key', full_name='HDNodeType.public_key', index=5, number=6, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=50, serialized_end=178, ) _HDNODEPATHTYPE = _descriptor.Descriptor( name='HDNodePathType', full_name='HDNodePathType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='node', full_name='HDNodePathType.node', index=0, number=1, type=11, cpp_type=10, label=2, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_n', full_name='HDNodePathType.address_n', index=1, number=2, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=180, serialized_end=242, ) _COINTYPE = _descriptor.Descriptor( name='CoinType', full_name='CoinType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='coin_name', full_name='CoinType.coin_name', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='coin_shortcut', full_name='CoinType.coin_shortcut', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_type', full_name='CoinType.address_type', index=2, number=3, type=13, cpp_type=3, label=1, has_default_value=True, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='maxfee_kb', full_name='CoinType.maxfee_kb', index=3, number=4, type=4, cpp_type=4, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_type_p2sh', full_name='CoinType.address_type_p2sh', index=4, number=5, type=13, cpp_type=3, label=1, has_default_value=True, default_value=5, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=244, serialized_end=370, ) _MULTISIGREDEEMSCRIPTTYPE = _descriptor.Descriptor( name='MultisigRedeemScriptType', full_name='MultisigRedeemScriptType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='pubkeys', full_name='MultisigRedeemScriptType.pubkeys', index=0, number=1, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='signatures', full_name='MultisigRedeemScriptType.signatures', index=1, number=2, type=12, cpp_type=9, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='m', full_name='MultisigRedeemScriptType.m', index=2, number=3, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=372, serialized_end=463, ) _TXINPUTTYPE = _descriptor.Descriptor( name='TxInputType', full_name='TxInputType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address_n', full_name='TxInputType.address_n', index=0, number=1, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='prev_hash', full_name='TxInputType.prev_hash', index=1, number=2, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='prev_index', full_name='TxInputType.prev_index', index=2, number=3, type=13, cpp_type=3, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='script_sig', full_name='TxInputType.script_sig', index=3, number=4, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='sequence', full_name='TxInputType.sequence', index=4, number=5, type=13, cpp_type=3, label=1, has_default_value=True, default_value=4294967295, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='script_type', full_name='TxInputType.script_type', index=5, number=6, type=14, cpp_type=8, label=1, has_default_value=True, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='multisig', full_name='TxInputType.multisig', index=6, number=7, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=466, serialized_end=685, ) _TXOUTPUTTYPE = _descriptor.Descriptor( name='TxOutputType', full_name='TxOutputType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='address', full_name='TxOutputType.address', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_n', full_name='TxOutputType.address_n', index=1, number=2, type=13, cpp_type=3, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='amount', full_name='TxOutputType.amount', index=2, number=3, type=4, cpp_type=4, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='script_type', full_name='TxOutputType.script_type', index=3, number=4, type=14, cpp_type=8, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='multisig', full_name='TxOutputType.multisig', index=4, number=5, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='op_return_data', full_name='TxOutputType.op_return_data', index=5, number=6, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='address_type', full_name='TxOutputType.address_type', index=6, number=7, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=688, serialized_end=905, ) _TXOUTPUTBINTYPE = _descriptor.Descriptor( name='TxOutputBinType', full_name='TxOutputBinType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='amount', full_name='TxOutputBinType.amount', index=0, number=1, type=4, cpp_type=4, label=2, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='script_pubkey', full_name='TxOutputBinType.script_pubkey', index=1, number=2, type=12, cpp_type=9, label=2, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=907, serialized_end=963, ) _TRANSACTIONTYPE = _descriptor.Descriptor( name='TransactionType', full_name='TransactionType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='version', full_name='TransactionType.version', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='inputs', full_name='TransactionType.inputs', index=1, number=2, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='bin_outputs', full_name='TransactionType.bin_outputs', index=2, number=3, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='outputs', full_name='TransactionType.outputs', index=3, number=5, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='lock_time', full_name='TransactionType.lock_time', index=4, number=4, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='inputs_cnt', full_name='TransactionType.inputs_cnt', index=5, number=6, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='outputs_cnt', full_name='TransactionType.outputs_cnt', index=6, number=7, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=966, serialized_end=1161, ) _TXREQUESTDETAILSTYPE = _descriptor.Descriptor( name='TxRequestDetailsType', full_name='TxRequestDetailsType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='request_index', full_name='TxRequestDetailsType.request_index', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='tx_hash', full_name='TxRequestDetailsType.tx_hash', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1163, serialized_end=1225, ) _TXREQUESTSERIALIZEDTYPE = _descriptor.Descriptor( name='TxRequestSerializedType', full_name='TxRequestSerializedType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='signature_index', full_name='TxRequestSerializedType.signature_index', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='signature', full_name='TxRequestSerializedType.signature', index=1, number=2, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='serialized_tx', full_name='TxRequestSerializedType.serialized_tx', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value="", message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1227, serialized_end=1319, ) _IDENTITYTYPE = _descriptor.Descriptor( name='IdentityType', full_name='IdentityType', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='proto', full_name='IdentityType.proto', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='user', full_name='IdentityType.user', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='host', full_name='IdentityType.host', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='port', full_name='IdentityType.port', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='path', full_name='IdentityType.path', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=False, default_value=unicode("", "utf-8"), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), _descriptor.FieldDescriptor( name='index', full_name='IdentityType.index', index=5, number=6, type=13, cpp_type=3, label=1, has_default_value=True, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, options=None), ], extensions=[ ], nested_types=[], enum_types=[ ], options=None, is_extendable=False, extension_ranges=[], serialized_start=1321, serialized_end=1424, ) _HDNODEPATHTYPE.fields_by_name['node'].message_type = _HDNODETYPE _MULTISIGREDEEMSCRIPTTYPE.fields_by_name['pubkeys'].message_type = _HDNODEPATHTYPE _TXINPUTTYPE.fields_by_name['script_type'].enum_type = _INPUTSCRIPTTYPE _TXINPUTTYPE.fields_by_name['multisig'].message_type = _MULTISIGREDEEMSCRIPTTYPE _TXOUTPUTTYPE.fields_by_name['script_type'].enum_type = _OUTPUTSCRIPTTYPE _TXOUTPUTTYPE.fields_by_name['multisig'].message_type = _MULTISIGREDEEMSCRIPTTYPE _TXOUTPUTTYPE.fields_by_name['address_type'].enum_type = _OUTPUTADDRESSTYPE _TRANSACTIONTYPE.fields_by_name['inputs'].message_type = _TXINPUTTYPE _TRANSACTIONTYPE.fields_by_name['bin_outputs'].message_type = _TXOUTPUTBINTYPE _TRANSACTIONTYPE.fields_by_name['outputs'].message_type = _TXOUTPUTTYPE DESCRIPTOR.message_types_by_name['HDNodeType'] = _HDNODETYPE DESCRIPTOR.message_types_by_name['HDNodePathType'] = _HDNODEPATHTYPE DESCRIPTOR.message_types_by_name['CoinType'] = _COINTYPE DESCRIPTOR.message_types_by_name['MultisigRedeemScriptType'] = _MULTISIGREDEEMSCRIPTTYPE DESCRIPTOR.message_types_by_name['TxInputType'] = _TXINPUTTYPE DESCRIPTOR.message_types_by_name['TxOutputType'] = _TXOUTPUTTYPE DESCRIPTOR.message_types_by_name['TxOutputBinType'] = _TXOUTPUTBINTYPE DESCRIPTOR.message_types_by_name['TransactionType'] = _TRANSACTIONTYPE DESCRIPTOR.message_types_by_name['TxRequestDetailsType'] = _TXREQUESTDETAILSTYPE DESCRIPTOR.message_types_by_name['TxRequestSerializedType'] = _TXREQUESTSERIALIZEDTYPE DESCRIPTOR.message_types_by_name['IdentityType'] = _IDENTITYTYPE class HDNodeType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _HDNODETYPE # @@protoc_insertion_point(class_scope:HDNodeType) class HDNodePathType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _HDNODEPATHTYPE # @@protoc_insertion_point(class_scope:HDNodePathType) class CoinType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _COINTYPE # @@protoc_insertion_point(class_scope:CoinType) class MultisigRedeemScriptType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _MULTISIGREDEEMSCRIPTTYPE # @@protoc_insertion_point(class_scope:MultisigRedeemScriptType) class TxInputType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXINPUTTYPE # @@protoc_insertion_point(class_scope:TxInputType) class TxOutputType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXOUTPUTTYPE # @@protoc_insertion_point(class_scope:TxOutputType) class TxOutputBinType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXOUTPUTBINTYPE # @@protoc_insertion_point(class_scope:TxOutputBinType) class TransactionType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TRANSACTIONTYPE # @@protoc_insertion_point(class_scope:TransactionType) class TxRequestDetailsType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXREQUESTDETAILSTYPE # @@protoc_insertion_point(class_scope:TxRequestDetailsType) class TxRequestSerializedType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _TXREQUESTSERIALIZEDTYPE # @@protoc_insertion_point(class_scope:TxRequestSerializedType) class IdentityType(_message.Message): __metaclass__ = _reflection.GeneratedProtocolMessageType DESCRIPTOR = _IDENTITYTYPE # @@protoc_insertion_point(class_scope:IdentityType) google.protobuf.descriptor_pb2.EnumValueOptions.RegisterExtension(wire_in) google.protobuf.descriptor_pb2.EnumValueOptions.RegisterExtension(wire_out) google.protobuf.descriptor_pb2.EnumValueOptions.RegisterExtension(wire_debug_in) google.protobuf.descriptor_pb2.EnumValueOptions.RegisterExtension(wire_debug_out) DESCRIPTOR.has_options = True DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), '\n\033com.keepkey.device-protocolB\013KeepKeyType') # @@protoc_insertion_point(module_scope) keepkey-0.7.3/MANIFEST.in0000644000076500000240000000004212717426464015145 0ustar darinstaff00000000000000recursive-include tests *.py *.sh keepkey-0.7.3/PKG-INFO0000644000076500000240000000102612726077014014500 0ustar darinstaff00000000000000Metadata-Version: 1.1 Name: keepkey Version: 0.7.3 Summary: Python library for communicating with KeepKey Hardware Wallet Home-page: https://github.com/keepkey/python-keepkey Author: Bitcoin TREZOR and KeepKey Author-email: support@keepkey.com License: UNKNOWN Description: UNKNOWN Platform: UNKNOWN Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: MacOS :: MacOS X keepkey-0.7.3/README.rst0000644000076500000240000000461412726074236015103 0ustar darinstaff00000000000000python-keepkey ============== Client side implementation for KeepKey-compatible Bitcoin hardware wallets. This is a modified version of python-trezor. The changes made were to support KeepKey's protocol, as well as the additional feature set of KeepKey. For example, by default, device_recovery command invokes KeepKey's style of device recovery using the Recovery Cipher. See http://www.keepkey.com for more information. Example ------- also found in ``helloworld.py`` .. code:: python #!/usr/bin/env python from keepkeylib.client import KeepKeyClient from keepkeylib.transport_hid import HidTransport 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('Bitcoin', bip32_path) print('Bitcoin address:', address) client.close() if __name__ == '__main__': main() PIN Entering ------------ When you are asked for PIN, you have to enter scrambled PIN. Follow the numbers shown on KeepKey display and enter the their positions using the numeric keyboard mapping: === === === 7 8 9 4 5 6 1 2 3 === === === Example: your PIN is **1234** and KeepKey is displaying the following: === === === 2 8 3 5 4 6 7 9 1 === === === You have to enter: **3795** How to install (Windows) ------------------------ * Install Python 2.7 (http://python.org) * Run C:\\python27\\scripts\\pip.exe install cython * Install Microsoft Visual C++ Compiler for Python 2.7 * Clone repository (using TortoiseGit) to local directory * Run C:\\python27\\python.exe setup.py install (or develop) How to install (Debian-Ubuntu) ------------------------------ * sudo apt-get install python-dev python-setuptools cython libusb-1.0-0-dev libudev-dev git * git clone https://github.com/keepkey/python-keepkey.git * cd python-keepkey * python setup.py install (or develop) keepkey-0.7.3/setup.cfg0000644000076500000240000000007312726077014015225 0ustar darinstaff00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 keepkey-0.7.3/setup.py0000755000076500000240000000247212726076702015131 0ustar darinstaff00000000000000#!/usr/bin/env python from setuptools import setup setup( name='keepkey', version='0.7.3', author='Bitcoin TREZOR and KeepKey', author_email='support@keepkey.com', description='Python library for communicating with KeepKey Hardware Wallet', url='https://github.com/keepkey/python-keepkey', py_modules=[ 'keepkeylib.ckd_public', 'keepkeylib.client', 'keepkeylib.debuglink', 'keepkeylib.mapping', 'keepkeylib.messages_pb2', 'keepkeylib.protobuf_json', 'keepkeylib.qt.pinmatrix', 'keepkeylib.tools', 'keepkeylib.transport', 'keepkeylib.transport_fake', 'keepkeylib.transport_hid', 'keepkeylib.transport_pipe', 'keepkeylib.transport_serial', 'keepkeylib.transport_socket', 'keepkeylib.tx_api', 'keepkeylib.types_pb2', ], scripts = ['keepkeyctl'], test_suite='tests', install_requires=['ecdsa>=0.9', 'protobuf>=2.6.1', 'mnemonic>=0.8', 'hidapi==0.7.99.post15'], include_package_data=True, zip_safe=False, classifiers=[ 'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)', 'Operating System :: POSIX :: Linux', 'Operating System :: Microsoft :: Windows', 'Operating System :: MacOS :: MacOS X', ], ) keepkey-0.7.3/tests/0000755000076500000240000000000012726077014014546 5ustar darinstaff00000000000000keepkey-0.7.3/tests/common.py0000644000076500000240000000577012726074236016424 0ustar darinstaff00000000000000from __future__ import print_function import unittest import config import time from keepkeylib.client import KeepKeyDebugClient from keepkeylib.tx_api import TXAPIBitcoin class KeepKeyTest(unittest.TestCase): def setUp(self): self.debug_transport = config.DEBUG_TRANSPORT(*config.DEBUG_TRANSPORT_ARGS, **config.DEBUG_TRANSPORT_KWARGS) self.transport = config.TRANSPORT(*config.TRANSPORT_ARGS, **config.TRANSPORT_KWARGS) self.client = KeepKeyDebugClient(self.transport) self.client.set_debuglink(self.debug_transport) self.client.set_tx_api(TXAPIBitcoin()) # self.client.set_buttonwait(3) # 1 2 3 4 5 6 7 8 9 10 11 12 self.mnemonic12 = 'alcohol woman abuse must during monitor noble actual mixed trade anger aisle' self.mnemonic18 = 'owner little vague addict embark decide pink prosper true fork panda embody mixture exchange choose canoe electric jewel' self.mnemonic24 = 'dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic' self.pin4 = '1234' self.pin6 = '789456' self.pin8 = '45678978' self.client.wipe_device() print("Setup finished") print("--------------") def setup_mnemonic_nopin_nopassphrase(self): self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin='', passphrase_protection=False, label='test', language='english') def setup_mnemonic_pin_nopassphrase(self): self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=False, label='test', language='english') def setup_mnemonic_pin_passphrase(self): self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=True, label='test', language='english') def tearDown(self): self.client.close() class KeepKeyBootloaderTest(unittest.TestCase): def setUp(self): self.debug_transport = config.DEBUG_TRANSPORT(*config.DEBUG_TRANSPORT_ARGS, **config.DEBUG_TRANSPORT_KWARGS) self.transport = config.TRANSPORT(*config.TRANSPORT_ARGS, **config.TRANSPORT_KWARGS) self.client = KeepKeyDebugClient(self.transport) self.client.set_debuglink(self.debug_transport) print("Setup finished") print("--------------") def reconnect(self): self.client.close() time.sleep(10) config.enumerate_hid() self.debug_transport = config.DEBUG_TRANSPORT(*config.DEBUG_TRANSPORT_ARGS, **config.DEBUG_TRANSPORT_KWARGS) self.transport = config.TRANSPORT(*config.TRANSPORT_ARGS, **config.TRANSPORT_KWARGS) self.client = KeepKeyDebugClient(self.transport) self.client.set_debuglink(self.debug_transport) print("Reconnected") print("--------------") def tearDown(self): self.client.close() time.sleep(10) config.enumerate_hid() keepkey-0.7.3/tests/config.py0000644000076500000240000000335412726074236016375 0ustar darinstaff00000000000000from __future__ import print_function import sys sys.path = ['../',] + sys.path from keepkeylib.transport_pipe import PipeTransport from keepkeylib.transport_hid import HidTransport from keepkeylib.transport_socket import SocketTransportClient from keepkeylib.transport_bridge import BridgeTransport devices = HidTransport.enumerate() if len(devices) > 0: if devices[0][1] != None: print('Using TREZOR') TRANSPORT = HidTransport TRANSPORT_ARGS = (devices[0],) TRANSPORT_KWARGS = {'debug_link': False} DEBUG_TRANSPORT = HidTransport DEBUG_TRANSPORT_ARGS = (devices[0],) DEBUG_TRANSPORT_KWARGS = {'debug_link': True} else: print('Using Raspberry Pi') TRANSPORT = HidTransport TRANSPORT_ARGS = (devices[0],) TRANSPORT_KWARGS = {'debug_link': False} DEBUG_TRANSPORT = SocketTransportClient DEBUG_TRANSPORT_ARGS = ('trezor.bo:2000',) DEBUG_TRANSPORT_KWARGS = {} else: print('Using Emulator') TRANSPORT = PipeTransport TRANSPORT_ARGS = ('/tmp/pipe.trezor', False) TRANSPORT_KWARGS = {} DEBUG_TRANSPORT = PipeTransport DEBUG_TRANSPORT_ARGS = ('/tmp/pipe.trezor_debug', False) DEBUG_TRANSPORT_KWARGS = {} def enumerate_hid(): global TRANSPORT, TRANSPORT_ARGS, TRANSPORT_KWARGS, DEBUG_TRANSPORT, DEBUG_TRANSPORT_ARGS, DEBUG_TRANSPORT_KWARGS devices = HidTransport.enumerate() if len(devices) > 0: if devices[0][1] != None: TRANSPORT = HidTransport TRANSPORT_ARGS = (devices[0],) TRANSPORT_KWARGS = {'debug_link': False} DEBUG_TRANSPORT = HidTransport DEBUG_TRANSPORT_ARGS = (devices[0],) DEBUG_TRANSPORT_KWARGS = {'debug_link': True} keepkey-0.7.3/tests/run-jenkins.sh0000755000076500000240000000370312717427115017354 0ustar darinstaff00000000000000export PYTHONIOENCODING=UTF-8 echo "RUNNING TEST test_basic.py" python test_basic.py echo "RUNNING TEST test_bip32_speed.py" python test_bip32_speed.py echo "RUNNING TEST test_debuglink.py" python test_debuglink.py echo "RUNNING TEST test_ecies.py" python test_ecies.py echo "RUNNING TEST test_msg_applysettings.py" python test_msg_applysettings.py echo "RUNNING TEST test_msg_changepin.py" python test_msg_changepin.py echo "RUNNING TEST test_msg_cipherkeyvalue.py" python test_msg_cipherkeyvalue.py echo "RUNNING TEST test_msg_clearsession.py" python test_msg_clearsession.py echo "RUNNING TEST test_msg_estimatetxsize.py" python test_msg_estimatetxsize.py echo "RUNNING TEST test_msg_getaddress.py" python test_msg_getaddress.py echo "RUNNING TEST test_msg_getaddress_show.py" python test_msg_getaddress_show.py echo "RUNNING TEST test_msg_getentropy.py" python test_msg_getentropy.py echo "RUNNING TEST test_msg_getpublickey.py" python test_msg_getpublickey.py echo "RUNNING TEST test_msg_loaddevice.py" python test_msg_loaddevice.py echo "RUNNING TEST test_msg_ping.py" python test_msg_ping.py echo "RUNNING TEST test_msg_recoverydevice.py" python test_msg_recoverydevice.py echo "RUNNING TEST test_msg_recoverydevice_cipher.py" python test_msg_recoverydevice_cipher.py echo "RUNNING TEST test_msg_resetdevice.py" python test_msg_resetdevice.py echo "RUNNING TEST test_msg_signmessage.py" python test_msg_signmessage.py echo "RUNNING TEST test_msg_signtx.py" python test_msg_signtx.py echo "RUNNING TEST test_msg_verifymessage.py" python test_msg_verifymessage.py echo "RUNNING TEST test_msg_wipedevice.py" python test_msg_wipedevice.py echo "RUNNING TEST test_multisig_change.py" python test_multisig_change.py echo "RUNNING TEST test_multisig.py" python test_multisig.py echo "RUNNING TEST test_protect_call.py" python test_protect_call.py #echo "RUNNING TEST test_protection_levels.py" #python test_protection_levels.py echo "RUNNING TEST test_zerosig.py" python test_zerosig.py keepkey-0.7.3/tests/run-separate.sh0000755000076500000240000000013312717427115017511 0ustar darinstaff00000000000000#!/bin/bash for i in test_*.py; do echo Starting: $i python $i > $i.out 2> $i.err done keepkey-0.7.3/tests/run.sh0000755000076500000240000000005112717427115015706 0ustar darinstaff00000000000000#!/bin/bash python -m unittest discover keepkey-0.7.3/tests/test_basic.py0000644000076500000240000000202012717427115017233 0ustar darinstaff00000000000000import unittest import common from keepkeylib import messages_pb2 as messages class TestBasic(common.KeepKeyTest): def test_features(self): features = self.client.call(messages.Initialize()) self.assertEqual(features, self.client.features) def test_ping(self): ping = self.client.call(messages.Ping(message='ahoj!')) self.assertEqual(ping, messages.Success(message='ahoj!')) def test_device_id_same(self): id1 = self.client.get_device_id() self.client.init_device() id2 = self.client.get_device_id() # ID must be at least 12 characters self.assertTrue(len(id1) >= 12) # Every resulf of UUID must be the same self.assertEqual(id1, id2) def test_device_id_different(self): id1 = self.client.get_device_id() self.client.wipe_device() id2 = self.client.get_device_id() # Device ID must be fresh after every reset self.assertNotEqual(id1, id2) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_bip32_speed.py0000644000076500000240000000347212726074236020267 0ustar darinstaff00000000000000from __future__ import print_function import unittest import common import time from keepkeylib import tools class TestBip32Speed(common.KeepKeyTest): def test_public_ckd(self): self.setup_mnemonic_nopin_nopassphrase() self.client.get_address('Bitcoin', []) # to compute root node via BIP39 for depth in range(8): start = time.time() self.client.get_address('Bitcoin', range(depth)) delay = time.time() - start expected = (depth + 1) * 0.31 print("DEPTH", depth, "EXPECTED DELAY", expected, "REAL DELAY", delay) self.assertLessEqual(delay, expected) def test_private_ckd(self): self.setup_mnemonic_nopin_nopassphrase() self.client.get_address('Bitcoin', []) # to compute root node via BIP39 for depth in range(8): start = time.time() self.client.get_address('Bitcoin', range(-depth, 0)) delay = time.time() - start expected = (depth + 1) * 0.31 print("DEPTH", depth, "EXPECTED DELAY", expected, "REAL DELAY", delay) self.assertLessEqual(delay, expected) """ def test_cache(self): self.setup_mnemonic_nopin_nopassphrase() start = time.time() for x in range(10): self.client.get_address('Bitcoin', [x, 2, 3, 4, 5, 6, 7, 8]) nocache_time = time.time() - start start = time.time() for x in range(10): self.client.get_address('Bitcoin', [1, 2, 3, 4, 5, 6, 7, x]) cache_time = time.time() - start print("NOCACHE TIME", nocache_time) print("CACHED TIME", cache_time) # Cached time expected to be at least 2x faster self.assertLessEqual(cache_time, nocache_time / 2.) """ if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_bootloader.py0000644000076500000240000001220212717427115020307 0ustar darinstaff00000000000000import time import unittest import common import hashlib import binascii import struct from keepkeylib import messages_pb2 as proto from keepkeylib import types_pb2 as proto_types class TestBootloader(common.KeepKeyBootloaderTest): def test_firmware_update_mode(self): self.client.init_device() self.assertEquals(self.client.features.bootloader_mode, True) def test_signed_firmware_upload(self): self.client.debug.fill_config() # get storage hash so we can compare it after upload original_flashed_firmware_hash, storage_hash = self.client.debug.read_memory_hashes() data = open('firmware_images/signed_firmware_correct.bin', 'r').read() firmware_hash = hashlib.sha256(data) # erase firmware ret = self.client.call(proto.FirmwareErase()) self.assertIsInstance(ret, proto.Success) # upload firmware ret = self.client.call_raw(proto.FirmwareUpload(payload_hash=firmware_hash.digest(), payload=data)) self.assertIsInstance(ret, proto.Success) self.reconnect() # get flashed hashes flashed_firmware_hash, storage_hash_after = self.client.debug.read_memory_hashes() # check that firmware hash is the same as we calculated client side self.assertEquals(firmware_hash.hexdigest(), binascii.hexlify(flashed_firmware_hash)) # make sure config flash got copied over self.assertEquals(storage_hash, storage_hash_after) def test_signed_wrong_firmware_upload(self): self.client.debug.fill_config() # get storage hash so we can compare it after upload original_flashed_firmware_hash, storage_hash = self.client.debug.read_memory_hashes() data = open('firmware_images/signed_firmware_wrong.bin', 'r').read() firmware_hash = hashlib.sha256(data) # erase firmware ret = self.client.call(proto.FirmwareErase()) self.assertIsInstance(ret, proto.Success) # upload firmware ret = self.client.call_raw(proto.FirmwareUpload(payload_hash=firmware_hash.digest(), payload=data)) self.assertIsInstance(ret, proto.Success) self.reconnect() # get flased hashes flashed_firmware_hash, storage_hash_after = self.client.debug.read_memory_hashes() # check that the flashed hash is the same as we calculated client side self.assertEquals(firmware_hash.hexdigest(), binascii.hexlify(flashed_firmware_hash)) # make sure config flash did not get copied over self.assertNotEquals(storage_hash, storage_hash_after) def test_unsigned_firmware_upload(self): # get storage hash so we can compare it after upload original_flashed_firmware_hash, storage_hash = self.client.debug.read_memory_hashes() data = open('firmware_images/firmware_no_magic.bin', 'r').read() firmware_hash = hashlib.sha256(data) # erase firmware ret = self.client.call(proto.FirmwareErase()) self.assertIsInstance(ret, proto.Success) # upload firmware ret = self.client.call_raw(proto.FirmwareUpload(payload_hash=firmware_hash.digest(), payload=data)) self.assertIsInstance(ret, proto.Failure) self.assertEquals(ret.message, 'Not valid firmware') def test_signed_firmware_too_large_upload(self): # get storage hash so we can compare it after upload original_flashed_firmware_hash, storage_hash = self.client.debug.read_memory_hashes() data = open('firmware_images/signed_firmware_correct_too_large.bin', 'r').read() firmware_hash = hashlib.sha256(data) # erase firmware ret = self.client.call(proto.FirmwareErase()) self.assertIsInstance(ret, proto.Success) # upload firmware ret = self.client.call_raw(proto.FirmwareUpload(payload_hash=firmware_hash.digest(), payload=data)) self.assertIsInstance(ret, proto.Failure) self.assertEquals(ret.message, 'Firmware too large') def test_signed_firmware_corrupted_upload(self): self.client.debug.fill_config() # get storage hash so we can compare it after upload original_flashed_firmware_hash, storage_hash = self.client.debug.read_memory_hashes() data = open('firmware_images/signed_firmware_correct_corrupted.bin', 'r').read() firmware_hash = hashlib.sha256(data) # erase firmware ret = self.client.call(proto.FirmwareErase()) self.assertIsInstance(ret, proto.Success) # upload firmware ret = self.client.call_raw(proto.FirmwareUpload(payload_hash=firmware_hash.digest(), payload=data)) self.assertIsInstance(ret, proto.Success) self.reconnect() # get flashed hashes flashed_firmware_hash, storage_hash_after = self.client.debug.read_memory_hashes() # check firmware hash written to flash is the same as we calculated client side self.assertEquals(firmware_hash.hexdigest(), binascii.hexlify(flashed_firmware_hash)) # make sure config flash did not get copied over self.assertNotEquals(storage_hash, storage_hash_after) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_debuglink.py0000644000076500000240000000231012717427115020120 0ustar darinstaff00000000000000import time import unittest import common import binascii from keepkeylib import messages_pb2 as proto from keepkeylib import types_pb2 as types from keepkeylib.client import PinException class TestDebugLink(common.KeepKeyTest): def test_mnemonic(self): self.setup_mnemonic_nopin_nopassphrase() mnemonic = self.client.debug.read_mnemonic() self.assertEqual(mnemonic, self.mnemonic12) def test_node(self): self.setup_mnemonic_nopin_nopassphrase() node = self.client.debug.read_node() self.assertIsNotNone(node) def test_pin(self): self.setup_mnemonic_pin_passphrase() self.client.clear_session() # Manually trigger PinMatrixRequest resp = self.client.call_raw(proto.Ping(message='test', pin_protection=True)) self.assertIsInstance(resp, proto.PinMatrixRequest) pin = self.client.debug.read_pin() self.assertEqual(pin[0], '1234') self.assertNotEqual(pin[1], '') pin_encoded = self.client.debug.read_pin_encoded() resp = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(resp, proto.Success) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_ecies.py0000644000076500000240000002544612726074236017265 0ustar darinstaff00000000000000from __future__ import print_function import unittest import common import binascii import base64 from keepkeylib.client import CallException # as described here: http://memwallet.info/btcmssgs.html def test_ecies_backforth(cls, test_string): cls.setup_mnemonic_nopin_nopassphrase() pubkey = binascii.unhexlify('0338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6') # encrypt without signature enc = cls.client.encrypt_message(pubkey, test_string, display_only=False, coin_name='Bitcoin', n=[]) print('base64:', base64.b64encode(enc.nonce + enc.message + enc.hmac)) dec = cls.client.decrypt_message([1], enc.nonce, enc.message, enc.hmac) cls.assertEqual(dec.message, test_string) cls.assertEqual(dec.address, '') # encrypt with signature enc = cls.client.encrypt_message(pubkey, test_string, display_only=False, coin_name='Bitcoin', n=[5]) print('base64:', base64.b64encode(enc.nonce + enc.message + enc.hmac)) dec = cls.client.decrypt_message([1], enc.nonce, enc.message, enc.hmac) cls.assertEqual(dec.message, test_string) cls.assertEqual(dec.address, '1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV') # encrypt without signature, show only on display enc = cls.client.encrypt_message(pubkey, test_string, display_only=True, coin_name='Bitcoin', n=[]) dec = cls.client.decrypt_message([1], enc.nonce, enc.message, enc.hmac) cls.assertEqual(dec.message, '') cls.assertEqual(dec.address, '') # encrypt with signature, show only on display enc = cls.client.encrypt_message(pubkey, test_string, display_only=True, coin_name='Bitcoin', n=[5]) dec = cls.client.decrypt_message([1], enc.nonce, enc.message, enc.hmac) cls.assertEqual(dec.message, '') cls.assertEqual(dec.address, '') class TestEcies(common.KeepKeyTest): # index: m/1 # address: 1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb # pubkey: 0338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6 # privkey: L5X3rf5hJfRt9ZjQzFopvSBGkpnSotn4jKGLL6ECJxcuT2JgGh65 # index: m/5 # address: 1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV # pubkey: 0234716c01c2dd03fa7ee302705e2b8fbd1311895d94b1dca15e62eedea9b0968f # privkey: L4uKPRgaZqL9iGmge3UBSLGTQC7gDFrLRhC1vM4LmGyrzNUBb1Zs def test_ecies_backforth_short(self): test_ecies_backforth(self, 'testing message!') def test_ecies_backforth_long(self): test_ecies_backforth(self, 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin elementum libero in tortor condimentum malesuada. Quisque gravida semper sapien, ut ultrices dolor pharetra nec. Nulla hendrerit metus imperdiet, feugiat sapien eu, fermentum mauris. Suspendisse nec bibendum urna. Vivamus augue libero, mollis vel augue at, venenatis vestibulum nunc. Curabitur condimentum quam non nibh volutpat, at congue libero rutrum. Morbi at sollicitudin lectus. Donec commodo rutrum sollicitudin. Vivamus condimentum massa id ligula iaculis, et aliquet orci condimentum. Nullam non ex sit amet nisi porta suscipit.') def test_ecies_crosscheck(self): self.setup_mnemonic_nopin_nopassphrase() # decrypt message without signature payload = 'AhA1yCZStrmtuGSgliJ7K02eD8xWRoyRU1ryPu9kBloODFv9hATpqukL0YSzISfrQGygYVai5OirxU0=' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, 'testing message!') self.assertEqual(dec.address, '') # decrypt message without signature (same message, different nonce) payload = 'A9ragu6UTXisBWw6bTCcM/SeR7fmlQp6Qzg9mpJ5qKBv9BIgWX/v/u+OhdlKLZTx6C0Xooz5aIvWrqw=' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, 'testing message!') self.assertEqual(dec.address, '') # decrypt message with signature payload = 'A90Awe+vrQvmzFvm0hh8Ver7jcBbqiCxV4RGU9knKf6F3vvG1N45Q3kc+N1sd4inzXZnW/5KH74CXaCPGAKr/a0n4BUhADVfS2Ic9Luwcs6/cuYHSzJKKLSPUYC6N4hu1K0q1vR/02BJ+iZ0pfvChoGDmpOOO7NaIEoyiKAnZFNsHr6Ffplg3YVGJAAG7GgfSQ==' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, 'testing message!') self.assertEqual(dec.address, '1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV') # decrypt message with signature (same message, different nonce) payload = 'AyeglkkBSc3VLNrXETiNtiS+t2nIKeEVGMVfF7KlVM+plBuX3yc+2kf+Yo6L1NKoqEjSlRXn71OTOEWfB2zmtasIX9dQBfyGluEivbeUfqbwneepEzv9/i0XI3ywfSa2HSdic8B68nZ3D6Mms4qOpzk6AEPt/yI7fl8aUsN0lxT8nVBfMmmg10oydvH/86cWYA==' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, 'testing message!') self.assertEqual(dec.address, '1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV') def test_ecies_crosscheck_long(self): self.setup_mnemonic_nopin_nopassphrase() lipsum = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin elementum libero in tortor condimentum malesuada. Quisque gravida semper sapien, ut ultrices dolor pharetra nec. Nulla hendrerit metus imperdiet, feugiat sapien eu, fermentum mauris. Suspendisse nec bibendum urna. Vivamus augue libero, mollis vel augue at, venenatis vestibulum nunc. Curabitur condimentum quam non nibh volutpat, at congue libero rutrum. Morbi at sollicitudin lectus. Donec commodo rutrum sollicitudin. Vivamus condimentum massa id ligula iaculis, et aliquet orci condimentum. Nullam non ex sit amet nisi porta suscipit.' # decrypt message without signature payload = 'AhnOXSv+7mI3Tvw0ekCxvEoMvophrWOGAwLT2IpyxaCd+zgftijj2uQoGtSktFwch8oABstTqwBjokH4AllH7PaL/8dWwOELwEVIXlbktf8nktUITBkJ0Abih8Imq451Bwrt8ZMt0tzoDBWeRLtZGHPduHnykGjq1O3A8Qjd4k8W+PkPBum+rNKlPOUqoNpSvOcPD9L6APkMByPKMmTq5K9nSeLKyXjOtWcx4BLRqRe9qgvG+SWFHsJ/90O76XZIB6GXDqGnCNR5rV/8Ho4bfagRL/tQPbeQ4iYWAyqdRlKuwnUrrZSJCdrsQJt1Ye5LcltE0YhJBKRmxob2/P+ziyceZk6cU3hS9k4B1GKlEeGxipvMswfbrEIy/5NYiGXEDwC3dHwM3g1Opz5oXbEKZ3NG/eEh5UxJFjfyx1qumQeSaIo5XFOf81A4dhH1vAT8MMEQN7bXXwCb1fxDC9wblCP9iVR1aey5FUFMNE7wfXYdrMxwzxrgJfSa8/vQgMmZI205OCBxAsmBYOTIy6kqcRn7+Ad6WEYvp2DRwcGN//9XFJi2DuJzA0ymeoSxnZg4GDytpvVFVyQvIDkPHrmVfaZot02XCCqTq/ZDgZLnnutWfP9dB1ckSpzXOM/pEgMBj6DcC1HbgHZaKhoNjsk8ITTYMnP5kFBoZdtPbNJB5rZOYtLHHDxfvk2d3USTxtbPiIE9w6JbBll18lKFMN8gvQuKcHyKwVNQGOVuBGtXv4hCBFF/VNRJ5GE8BX1ajHwldFiuTII9dcdSrZhL+Ds8Ui0siZ5Ai+KHjKZi8FciNQ+8q3tXUOiN1hONCN6iy5XjFd2I7NAqg+o4TnkGKSPMQSE3z2vY' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, lipsum) self.assertEqual(dec.address, '') # decrypt message without signature (same message, different nonce) payload = 'A2bVIKzpPVYJlPP6WMiwhpabJfJAHH927StDsUyRL2h3xc/aMPVN6rYA9GwcsPSDiZpPZdjCVYM4uDwFQ/kBNA1p5XlDs6IBGtGGgbR7P5wHgJaxcw1zWZ+TsWTIWVj3psy0CFg7zCfqeV2y0OzIvJc/p+ONdVb1f9TmTICPoVGJ9AVXdnfdqdIn+wLYScUklTp10ldfUCmt5iAsJJR1p+h+xa+wwUdyCxpvnxOZDxA0EFmxQskBhcDbLL2nmQkLm5RnLQgpefMCEJrdz5g9htC5y65eod2SFBV8oJrN1ryh4PdRn5+JyVcwWhQeCHTK3m6vOIwwht5lm2uCLpcEttDoxo5k3LcBPE4rlPVYCf8qja6sRKq/WYiLdwXnooX/qmmLQ7Lo2DBs4hB6VQGgPSSTH/3/rUb11bL2Ieyq73ZICeIbHCIvjFqhd/atkNvQTnCrNmFybyxdMqE/4Yrv7b//hJVkgI21AVGcSYF+Kp9pZ6XJVunDTS4XX7tjkXTFu7qbIv6q7mGgXV2/7udR9GF/lG/Us+wYsU1wmCEaUJ5Mx1yr4eLJ8cp6XPCMivEwKJ6CeHz2d/FYEeHE3YTy3VQT/+BJ5nS2+wDTD57wW9ZxUXn0cqPUhH0XveeRDOKEz1tgu6ChPrSyuu9E+pxDA2OA95NRt5j+UMdhZf6R0qgwfuDOcTs+0EuF9pQ5znPnmg4JqF6AkLlwE6txm1YTTjID8689yY4UsEc7CYJb1N3JvNxIHety5B5KWWAgnK1l9g9xnuKdGC4M7F+ajrbRqbw0qfTUvruD7GaYoqsyrdtDkEpEDXhZ0p56LALTUhL4+QVmeXvkH8cmBqdB6flZ48mlTgfy' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, lipsum) self.assertEqual(dec.address, '') # decrypt message with signature payload = 'ArJoHqnmLY22QiCePXk9yNQSK6g8BMGLkKkj72p35hCW1gxVajIZyptgbBp4A0LV8Fshe6MKnHO5PGw2BPQ6yTES5Q+7c8ZjC4m8JCKOOU8l7et4AcftPElxBdKimEv5B5egQmzSYds6dfB73VsWi2k9J/1RpckB2WDvXSrF1915XA4tMTMefB/DhzdrG9gkVTBqaROTgxlXWJhqdFag4aghVcXS5Ru6CQH0cLoxmZWf8mx/pK4liXyH1Gm+7fl8cd9iDkNTJEapzn/Ohh7JYxJrV/i4p0xE9L5CONL+UIL8DtGB8SgAWtd5cHdpLhMywRFxjDvho20nE3VyGREhqiv9i3ywXRox/zd6OFBkxSA3kuWNRrkDRBx4Q+2j49V5iQquuu5horUuRRYN1HVvoOYjVkfEJV70yvVg3xR2MeJouUa1aP7WF9JPo8vor252/ZU6L15mveE0JZH1HtoierC1Q5YDSFCYJ4hWJbWZEMwXvRBQL+FoZ5x6CSkrfTOYoP+uD/VnsMepI+0NgsssacU9h2PdDVy3pYnB0m04YpOftVnAARaun+nE9ti1FUFfnwSmD2vB2TfWEkFGQ3S6W6sjpX/gN+It6GViiNQO6yT9e3HO/4+JiS5yldOI7ryAlzNM598RANDdpI3kBy9IWKD5dENy/82TD/DAWoeRAz/LvvZaQBtpxZNEkRqqgbpBT7aJzjZudVMzZHPduF67eC994WB0EJHbKncXElbBVKXKMyoPruw9wwFP7VfeAAp4SLAmcs6YFkJ8lOeYO0bnPhvlrYV9XAkSpsHxBtita3WuyeoBHugHYEPzbNOdCoLRUgCS+4esrVV9aE1irlBzTmU+t8cWX5BQGsqnEuBKqPri7XWLrg57Up4ILkPFojgw/fIIkUNVCY2iqgFQCQZPM8dbE0wKK5ujd5YQwp8i/OrsXccin/TRjKXLtIkiEVg/Gl7aCRuXzGR0pfc=' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, lipsum) self.assertEqual(dec.address, '1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV') # decrypt message with signature (same message, different nonce) payload = 'AjFarEh66x2DZ9S3T/n8/xnYZQRwnuugxCDfIIEDPKkdfgwYPjGhtg3k/9ryj42MDgmey71ZvDhUdj+igcBKaPiKAS7p88kQxl6R6sFkL/wKwTdXPboA/n63BnHrtNNDIp12Dlgn2m0nSCLOchlh2maIBqB68qIqy21tT10ZrMpTfPd+4MI4NOzs42BQJAOLy19rMTKoCXGWIsgEERG0qCm38onYVUmj5UvtQIdDLIZ/ta4WD+FqM3Y9pJsU648qV72l/xM27BjIxVqUsw6MHLrAUNTmmd+D7dPAIjL66Gr5hEHCTcHP8oCIkeC+MK2JVcHN12F1Rx+8iwNf4nsixUcZJ/RX9JOTxJj3CdxuTH3b0lDNdFwQQddYhHd6cv4t1cZ3wOWAVh1g+gmB/igmvJD200EfhQudHp/w+9BIFFfxFwAmf4/tlidJ0knIaPjNx5kBSkklhxWdBfen5kgkGFtcQdBkguADcV/bfAxCRpqVa9lgN4ja2na0fUMZaAnVjR+sk4MWTbSObw5FBos3B7awAgRxQx6L8p3PUwGc2B9oVf1zcw3c0mlVUpaVEc7tXipVX6LAtKF9jx+EeMHvWlUic7s4vaGa7VxNuU8Of65Ba3RmxAX9zxwTKHMBAhm2efaqBIxGUSO8ncDSdp2nO6tJUkUoyNK0nasXWF2Ras22We0Ma0yGv0MQRVWeksYQn116I7ahv+lvAzaJnhiYGCM36Vg051VZEmBh23U5HdqrLRT7w8u1DJZyCxo0KmiZ5c3sOiJPxcC/8hpnQ0Zc7ipEdi97hZG2X2HOtmEIFivF2yI26rieEDyebbg95CnhUFx1LEuiEApU8fVAuYoyEQGVVwQPEQlBrqkF4oE/cItesBqxIdoZlsvoYBvxa1huT6jsc/Uci1WRpwKmPxeHUkxZrwLG8+kUNGFn13s8HrPTncaCQU3fnu3KOKkfLdnpVnF3JfYlrruMWV4=' payload = base64.b64decode(payload) nonce, msg, hmac = payload[:33], payload[33:-8], payload[-8:] dec = self.client.decrypt_message([1], nonce, msg, hmac) self.assertEqual(dec.message, lipsum) self.assertEqual(dec.address, '1Csf6LVPkv24FBs6bpj4ELPszE6mGf6jeV') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_applysettings.py0000644000076500000240000000464012717427115021740 0ustar darinstaff00000000000000import time import unittest import common from keepkeylib import messages_pb2 as proto class TestMsgApplysettings(common.KeepKeyTest): def test_apply_settings(self): self.setup_mnemonic_pin_passphrase() self.assertEqual(self.client.features.label, 'test') with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) self.client.apply_settings(label='new label') self.assertEqual(self.client.features.label, 'new label') def test_invalid_language(self): self.setup_mnemonic_pin_passphrase() self.assertEqual(self.client.features.language, 'english') with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) self.client.apply_settings(language='nonexistent') self.assertEqual(self.client.features.language, 'english') def test_apply_settings_passphrase(self): self.setup_mnemonic_pin_nopassphrase() self.assertEqual(self.client.features.passphrase_protection, False) with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) self.client.apply_settings(use_passphrase=True) self.assertEqual(self.client.features.passphrase_protection, True) with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) self.client.apply_settings(use_passphrase=False) self.assertEqual(self.client.features.passphrase_protection, False) with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) self.client.apply_settings(use_passphrase=True) self.assertEqual(self.client.features.passphrase_protection, True) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_changepin.py0000644000076500000240000001772512717427115020776 0ustar darinstaff00000000000000import time import unittest import common from keepkeylib import messages_pb2 as proto from keepkeylib import types_pb2 as proto_types class TestMsgChangepin(common.KeepKeyTest): def test_set_pin(self): self.setup_mnemonic_nopin_nopassphrase() features = self.client.call_raw(proto.Initialize()) self.assertFalse(features.pin_protection) # Check that there's no PIN protection ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.Success) # Let's set new PIN ret = self.client.call_raw(proto.ChangePin()) self.assertIsInstance(ret, proto.ButtonRequest) # Press button self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # Send the PIN for first time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send the PIN for second time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Now we're done self.assertIsInstance(ret, proto.Success) self.client.clear_session() # Check that there's PIN protection now features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) # Check that the PIN is correct self.assertEqual(self.client.debug.read_pin()[0], self.pin6) def test_change_pin(self): self.setup_mnemonic_pin_passphrase() features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) self.client.clear_session() # Check that there's PIN protection ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) # Check current PIN value self.assertEqual(self.client.debug.read_pin()[0], self.pin4) # Let's change PIN ret = self.client.call_raw(proto.ChangePin()) self.assertIsInstance(ret, proto.ButtonRequest) # Press button self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # Send current PIN self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.read_pin_encoded() ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send new PIN for first time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send the PIN for second time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Now we're done self.assertIsInstance(ret, proto.Success) self.client.clear_session() # Check that there's still PIN protection now features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) # Check that the PIN is correct self.assertEqual(self.client.debug.read_pin()[0], self.pin6) def test_remove_pin(self): self.setup_mnemonic_pin_passphrase() features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) self.client.clear_session() # Check that there's PIN protection ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) # Let's remove PIN ret = self.client.call_raw(proto.ChangePin(remove=True)) self.assertIsInstance(ret, proto.ButtonRequest) # Press button self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # Send current PIN self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.read_pin_encoded() ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Now we're done self.assertIsInstance(ret, proto.Success) # Check that there's no PIN protection now features = self.client.call_raw(proto.Initialize()) self.assertFalse(features.pin_protection) ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.Success) def test_set_failed(self): self.setup_mnemonic_nopin_nopassphrase() features = self.client.call_raw(proto.Initialize()) self.assertFalse(features.pin_protection) # Check that there's no PIN protection ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.Success) # Let's set new PIN ret = self.client.call_raw(proto.ChangePin()) self.assertIsInstance(ret, proto.ButtonRequest) # Press button self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # Send the PIN for first time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send the PIN for second time, but with typo self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin4) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Now it should fail, because pins are different self.assertIsInstance(ret, proto.Failure) # Check that there's still no PIN protection now features = self.client.call_raw(proto.Initialize()) self.assertFalse(features.pin_protection) ret = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(ret, proto.Success) def test_set_failed_2(self): self.setup_mnemonic_pin_passphrase() features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) # Let's set new PIN ret = self.client.call_raw(proto.ChangePin()) self.assertIsInstance(ret, proto.ButtonRequest) # Press button self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # Send current PIN self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.read_pin_encoded() ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send the PIN for first time self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Send the PIN for second time, but with typo self.assertIsInstance(ret, proto.PinMatrixRequest) pin_encoded = self.client.debug.encode_pin(self.pin6 + '3') ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Now it should fail, because pins are different self.assertIsInstance(ret, proto.Failure) # Check that there's still old PIN protection features = self.client.call_raw(proto.Initialize()) self.assertTrue(features.pin_protection) self.assertEqual(self.client.debug.read_pin()[0], self.pin4) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_cipherkeyvalue.py0000644000076500000240000000760312717427115022054 0ustar darinstaff00000000000000import unittest import common import binascii from keepkeylib.client import CallException class TestMsgCipherkeyvalue(common.KeepKeyTest): def test_encrypt(self): self.setup_mnemonic_nopin_nopassphrase() # different ask values res = self.client.encrypt_keyvalue([0, 1, 2], "test", "testing message!", ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(binascii.hexlify(res), '676faf8f13272af601776bc31bc14e8f') res = self.client.encrypt_keyvalue([0, 1, 2], "test", "testing message!", ask_on_encrypt=True, ask_on_decrypt=False) self.assertEqual(binascii.hexlify(res), '5aa0fbcb9d7fa669880745479d80c622') res = self.client.encrypt_keyvalue([0, 1, 2], "test", "testing message!", ask_on_encrypt=False, ask_on_decrypt=True) self.assertEqual(binascii.hexlify(res), '958d4f63269b61044aaedc900c8d6208') res = self.client.encrypt_keyvalue([0, 1, 2], "test", "testing message!", ask_on_encrypt=False, ask_on_decrypt=False) self.assertEqual(binascii.hexlify(res), 'e0cf0eb0425947000eb546cc3994bc6c') # different key res = self.client.encrypt_keyvalue([0, 1, 2], "test2", "testing message!", ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(binascii.hexlify(res), 'de247a6aa6be77a134bb3f3f925f13af') # different message res = self.client.encrypt_keyvalue([0, 1, 2], "test", "testing message! it is different", ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(binascii.hexlify(res), '676faf8f13272af601776bc31bc14e8f3ae1c88536bf18f1b44f1e4c2c4a613d') # different path res = self.client.encrypt_keyvalue([0, 1, 3], "test", "testing message!", ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(binascii.hexlify(res), 'b4811a9d492f5355a5186ddbfccaae7b') def test_decrypt(self): self.setup_mnemonic_nopin_nopassphrase() # different ask values res = self.client.decrypt_keyvalue([0, 1, 2], "test", binascii.unhexlify("676faf8f13272af601776bc31bc14e8f"), ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(res, 'testing message!') res = self.client.decrypt_keyvalue([0, 1, 2], "test", binascii.unhexlify("5aa0fbcb9d7fa669880745479d80c622"), ask_on_encrypt=True, ask_on_decrypt=False) self.assertEqual(res, 'testing message!') res = self.client.decrypt_keyvalue([0, 1, 2], "test", binascii.unhexlify("958d4f63269b61044aaedc900c8d6208"), ask_on_encrypt=False, ask_on_decrypt=True) self.assertEqual(res, 'testing message!') res = self.client.decrypt_keyvalue([0, 1, 2], "test", binascii.unhexlify("e0cf0eb0425947000eb546cc3994bc6c"), ask_on_encrypt=False, ask_on_decrypt=False) self.assertEqual(res, 'testing message!') # different key res = self.client.decrypt_keyvalue([0, 1, 2], "test2", binascii.unhexlify("de247a6aa6be77a134bb3f3f925f13af"), ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(res, 'testing message!') # different message res = self.client.decrypt_keyvalue([0, 1, 2], "test", binascii.unhexlify("676faf8f13272af601776bc31bc14e8f3ae1c88536bf18f1b44f1e4c2c4a613d"), ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(res, 'testing message! it is different') # different path res = self.client.decrypt_keyvalue([0, 1, 3], "test", binascii.unhexlify("b4811a9d492f5355a5186ddbfccaae7b"), ask_on_encrypt=True, ask_on_decrypt=True) self.assertEqual(res, 'testing message!') def test_encrypt_badlen(self): self.setup_mnemonic_nopin_nopassphrase() self.assertRaises(Exception, self.client.encrypt_keyvalue, [0, 1, 2], "test", "testing") def test_decrypt_badlen(self): self.setup_mnemonic_nopin_nopassphrase() self.assertRaises(Exception, self.client.decrypt_keyvalue, [0, 1, 2], "test", "testing") if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_clearsession.py0000644000076500000240000000346312726074236021530 0ustar darinstaff00000000000000import time import unittest import common from keepkeylib import messages_pb2 as proto from keepkeylib import types_pb2 as proto_types class TestMsgClearsession(common.KeepKeyTest): def test_clearsession(self): self.setup_mnemonic_pin_passphrase() with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.PassphraseRequest(), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') with self.client: # pin and passphrase are cached self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') self.client.clear_session() # session cache is cleared with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.PinMatrixRequest(), proto.PassphraseRequest(), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') with self.client: # pin and passphrase are cached self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_estimatetxsize.py0000644000076500000240000000227012717427115022111 0ustar darinstaff00000000000000import unittest import common import binascii import keepkeylib.messages_pb2 as proto import keepkeylib.types_pb2 as proto_types from keepkeylib.client import CallException class TestMsgEstimatetxsize(common.KeepKeyTest): def test_estimate_size(self): self.setup_mnemonic_nopin_nopassphrase() inp1 = proto_types.TxInputType(address_n=[0], # 14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e # amount=390000, prev_hash=binascii.unhexlify('d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882'), prev_index=0, ) out1 = proto_types.TxOutputType(address='1MJ2tj2ThBE62zXbBYA5ZaN3fdve5CPAz1', amount=390000 - 10000, script_type=proto_types.PAYTOADDRESS, ) est_size = self.client.estimate_tx_size('Bitcoin', [inp1, ], [out1, ]) self.assertEqual(est_size, 194) (_, tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) real_size = len(tx) self.assertGreaterEqual(est_size, real_size) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_getaddress.py0000644000076500000240000000420312717427115021152 0ustar darinstaff00000000000000import unittest import common import keepkeylib.ckd_public as bip32 class TestMsgGetaddress(common.KeepKeyTest): def test_btc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(self.client.get_address('Bitcoin', []), '1EfKbQupktEMXf4gujJ9kCFo83k1iMqwqK') self.assertEqual(self.client.get_address('Bitcoin', [1]), '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb') self.assertEqual(self.client.get_address('Bitcoin', [0, -1]), '1JVq66pzRBvqaBRFeU9SPVvg3er4ZDgoMs') self.assertEqual(self.client.get_address('Bitcoin', [-9, 0]), '1F4YdQdL9ZQwvcNTuy5mjyQxXkyCfMcP2P') self.assertEqual(self.client.get_address('Bitcoin', [0, 9999999]), '1GS8X3yc7ntzwGw9vXwj9wqmBWZkTFewBV') def test_ltc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(self.client.get_address('Litecoin', []), 'LYtGrdDeqYUQnTkr5sHT2DKZLG7Hqg7HTK') self.assertEqual(self.client.get_address('Litecoin', [1]), 'LKRGNecThFP3Q6c5fosLVA53Z2hUDb1qnE') self.assertEqual(self.client.get_address('Litecoin', [0, -1]), 'LcinMK8pVrAtpz7Qpc8jfWzSFsDLgLYfG6') self.assertEqual(self.client.get_address('Litecoin', [-9, 0]), 'LZHVtcwAEDf1BR4d67551zUijyLUpDF9EX') self.assertEqual(self.client.get_address('Litecoin', [0, 9999999]), 'Laf5nGHSCT94C5dK6fw2RxuXPiw2ZuRR9S') def test_tbtc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(self.client.get_address('Testnet', [111, 42]), 'moN6aN6NP1KWgnPSqzrrRPvx2x1UtZJssa') def test_public_ckd(self): self.setup_mnemonic_nopin_nopassphrase() node = self.client.get_public_node([]).node node_sub1 = self.client.get_public_node([1]).node node_sub2 = bip32.public_ckd(node, [1]) self.assertEqual(node_sub1.chain_code, node_sub2.chain_code) self.assertEqual(node_sub1.public_key, node_sub2.public_key) address1 = self.client.get_address('Bitcoin', [1]) address2 = bip32.get_address(node_sub2, 0) self.assertEqual(address2, '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb') self.assertEqual(address1, address2) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_getaddress_show.py0000644000076500000240000000431712717427115022220 0ustar darinstaff00000000000000import unittest import common import keepkeylib.ckd_public as bip32 import keepkeylib.types_pb2 as proto_types import binascii class TestMsgGetaddress(common.KeepKeyTest): def test_show(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(self.client.get_address('Bitcoin', [1], show_display=True), '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb') self.assertEqual(self.client.get_address('Bitcoin', [2], show_display=True), '15AeAhtNJNKyowK8qPHwgpXkhsokzLtUpG') self.assertEqual(self.client.get_address('Bitcoin', [3], show_display=True), '1CmzyJp9w3NafXMSEFH4SLYUPAVCSUrrJ5') def test_show_multisig_3(self): self.setup_mnemonic_nopin_nopassphrase() node = bip32.deserialize('xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy') multisig = proto_types.MultisigRedeemScriptType( pubkeys=[proto_types.HDNodePathType(node=node, address_n=[1]), proto_types.HDNodePathType(node=node, address_n=[2]), proto_types.HDNodePathType(node=node, address_n=[3])], signatures=['', '', ''], m=2, ) for i in [1, 2, 3]: self.assertEqual(self.client.get_address('Bitcoin', [i], show_display=True, multisig=multisig), '3E7GDtuHqnqPmDgwH59pVC7AvySiSkbibz') def test_show_multisig_15(self): self.setup_mnemonic_nopin_nopassphrase() node = bip32.deserialize('xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy') pubs = [] for x in range(15): pubs.append(proto_types.HDNodePathType(node=node, address_n=[x])) multisig = proto_types.MultisigRedeemScriptType( pubkeys=pubs, signatures=[''] * 15, m=15, ) for i in range(15): self.assertEqual(self.client.get_address('Bitcoin', [i], show_display=True, multisig=multisig), '3QaKF8zobqcqY8aS6nxCD5ZYdiRfL3RCmU') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_getentropy.py0000644000076500000240000000172112726074236021231 0ustar darinstaff00000000000000from __future__ import print_function import unittest import common import math import keepkeylib.messages_pb2 as proto import keepkeylib.types_pb2 as proto_types def entropy(data): counts = {} for c in data: if c in counts: counts[c] += 1 else: counts[c] = 1 e = 0 for _, v in counts.iteritems(): p = 1.0 * v / len(data) e -= p * math.log(p, 256) return e class TestMsgGetentropy(common.KeepKeyTest): def test_entropy(self): for l in [0, 1, 2, 3, 4, 5, 8, 9, 16, 17, 32, 33, 64, 65, 128, 129, 256, 257, 512, 513, 1024]: with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_GenerateEntropy), proto.Entropy()]) ent = self.client.get_entropy(l) self.assertTrue(len(ent) >= l) print('entropy = ', entropy(ent)) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_getpublickey.py0000644000076500000240000000523212717427115021517 0ustar darinstaff00000000000000import unittest import common import keepkeylib.ckd_public as bip32 class TestMsgGetpublic_key(common.KeepKeyTest): def test_btc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(bip32.serialize(self.client.get_public_node([]).node, 0x0488B21E), 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy') self.assertEqual(bip32.serialize(self.client.get_public_node([1]).node, 0x0488B21E), 'xpub68zNxjsTrV8y9AadThLW7dTAqEpZ7xBLFSyJ3X9pjTv6Njg6kxgjXJkzxq8u3ttnjBw1jupQHMP3gpGZzZqd1eh5S4GjkaMhPR18vMyUi8N') self.assertEqual(bip32.serialize(self.client.get_public_node([0, -1]).node, 0x0488B21E), 'xpub6A3FoZqYXj1AbW4thRwBh26YwZWbmoyjTaZwwxJjY1oKUpefLepL3RFS9DHKQrjAfxDrzDepYMDZPqXN6upQm3bHQ9xaXD5a3mqni3goF4v') self.assertEqual(bip32.serialize(self.client.get_public_node([-9, 0]).node, 0x0488B21E), 'xpub6A2h5mzLDfYginoD7q7wCWbq18wTbN9gducRr2w5NRTwdLeoT3cJSwefFqW7uXTpVFGtpUyDMBNYs3DNvvXx6NPjF9YEbUQrtxFSWnPtVrv') self.assertEqual(bip32.serialize(self.client.get_public_node([0, 9999999]).node, 0x0488B21E), 'xpub6A3FoZqQEK6iwLZ4HFkqSo5fb35BH4bpjC4SPZ63prfLdGYPwYxEuC6o91bUvFFdMzKWe5rs3axHRUjxJaSvBnKKFtnfLwDACRxPxabsv2r') def test_ltc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(bip32.serialize(self.client.get_public_node([]).node, 0x019dA462), 'Ltub2SSUS19CirucVPGDKDBatBDBEM2s9UbH66pBURfaKrMocCPLhQ7Z7hecy5VYLHA5fRdXwB2e61j2VJCNzVsqKTCVEU1vECjqi5EyczFX9xp') self.assertEqual(bip32.serialize(self.client.get_public_node([1]).node, 0x019dA462), 'Ltub2VRVRP5VjvSyPXra4BLVyVZPv397sjhUNjBGsbtw6xko77JuQyBULxFSKheviJJ3KQLbL3Cx8P2RnudguTw4raUVjCACRG7jsumUptYx55C') self.assertEqual(bip32.serialize(self.client.get_public_node([0, -1]).node, 0x019dA462), 'Ltub2WUNGD3aRAKAqsLqHuwBYtCn2MqAXbVsarmvn33quWe2DCHTzfK4s4jsW5oM5G8RGAdSaM3NPNrwVvtV1ourbyNhhHr3BtqcYGc8caf5GoT') self.assertEqual(bip32.serialize(self.client.get_public_node([-9, 0]).node, 0x019dA462), 'Ltub2WToYRCN76rgyA59iK7w4Ni45wG2M9fpmBpQg7gBjvJeMiHc7473Gb96ci29Zvs55TgUQcMmCD1vy8aVqpdPwJB9YHRhGAAuPT1nRLLXmFu') self.assertEqual(bip32.serialize(self.client.get_public_node([0, 9999999]).node, 0x019dA462), 'Ltub2WUNGD3S7kQjBhpzsjkqJfBtfqPk2r7xrUGRDdqACMW3MeBCbZSyiqbEVt7WaeesxCj6EDFQtcbfXa75DUYN2i6jZ2g81cyCgvijs9J2u2n') def test_tbtc(self): self.setup_mnemonic_nopin_nopassphrase() self.assertEqual(bip32.serialize(self.client.get_public_node([111, 42]).node, 0x043587CF), 'tpubDAgixSyai5PWbc8N1mBkHDR5nLgAnHFtY7r4y5EzxqAxrt9YUDpZL3kaRoHVvCfrcwNo31c2isBP2uTHcZxEosuKbyJhCAbrvGoPuLUZ7Mz') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_loaddevice.py0000644000076500000240000001135212717427115021127 0ustar darinstaff00000000000000import unittest import common from keepkeylib import messages_pb2 as messages class TestDeviceLoad(common.KeepKeyTest): def test_load_device_1(self): self.setup_mnemonic_nopin_nopassphrase() mnemonic = self.client.debug.read_mnemonic() self.assertEqual(mnemonic, self.mnemonic12) pin = self.client.debug.read_pin()[0] self.assertEqual(pin, '') passphrase_protection = self.client.debug.read_passphrase_protection() self.assertEqual(passphrase_protection, False) def test_load_device_2(self): self.setup_mnemonic_pin_passphrase() mnemonic = self.client.debug.read_mnemonic() self.assertEqual(mnemonic, self.mnemonic12) pin = self.client.debug.read_pin()[0] self.assertEqual(pin, self.pin4) passphrase_protection = self.client.debug.read_passphrase_protection() self.assertEqual(passphrase_protection, True) def test_load_device_3(self): self.client.load_device_by_xprv(xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=False, label='test', language='english') passphrase_protection = self.client.debug.read_passphrase_protection() self.assertEqual(passphrase_protection, False) address = self.client.get_address('Bitcoin', []) self.assertEqual(address, '128RdrAkJDmqasgvfRf6MC5VcX4HKqH4mR') def test_load_device_4(self): self.client.load_device_by_xprv(xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=True, label='test', language='english') self.client.set_passphrase('passphrase') passphrase_protection = self.client.debug.read_passphrase_protection() self.assertEqual(passphrase_protection, True) address = self.client.get_address('Bitcoin', []) self.assertEqual(address, '1CHUbFa4wTTPYgkYaw2LHSd5D4qJjMU8ri') def test_load_device_utf(self): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' words_nfkc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' words_nfd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' passphrase_nfkd = u'Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko' passphrase_nfc = u'Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko' passphrase_nfkc = u'Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko' passphrase_nfd = u'Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko' self.client.wipe_device() self.client.load_device_by_mnemonic(mnemonic=words_nfkd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfkd) address_nfkd = self.client.get_address('Bitcoin', []) self.client.wipe_device() self.client.load_device_by_mnemonic(mnemonic=words_nfc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfc) address_nfc = self.client.get_address('Bitcoin', []) self.client.wipe_device() self.client.load_device_by_mnemonic(mnemonic=words_nfkc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfkc) address_nfkc = self.client.get_address('Bitcoin', []) self.client.wipe_device() self.client.load_device_by_mnemonic(mnemonic=words_nfd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfd) address_nfd = self.client.get_address('Bitcoin', []) self.assertEqual(address_nfkd, address_nfc) self.assertEqual(address_nfkd, address_nfkc) self.assertEqual(address_nfkd, address_nfd) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_ping.py0000644000076500000240000000413212726074236017765 0ustar darinstaff00000000000000import time import unittest import common from keepkeylib import messages_pb2 as proto from keepkeylib import types_pb2 as proto_types class TestPing(common.KeepKeyTest): def test_ping(self): self.setup_mnemonic_pin_passphrase() self.client.clear_session() with self.client: self.client.set_expected_responses([proto.Success()]) res = self.client.ping('random data') self.assertEqual(res, 'random data') with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.Success()]) res = self.client.ping('random data', button_protection=True) self.assertEqual(res, 'random data') with self.client: self.client.set_expected_responses([proto.PinMatrixRequest(), proto.Success()]) res = self.client.ping('random data', pin_protection=True) self.assertEqual(res, 'random data') with self.client: self.client.set_expected_responses([proto.PassphraseRequest(), proto.Success()]) res = self.client.ping('random data', passphrase_protection=True) self.assertEqual(res, 'random data') def test_ping_caching(self): self.setup_mnemonic_pin_passphrase() self.client.clear_session() with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.PinMatrixRequest(), proto.PassphraseRequest(), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') with self.client: # pin and passphrase are cached self.client.set_expected_responses([proto.ButtonRequest(code=proto_types.ButtonRequest_Ping), proto.Success()]) res = self.client.ping('random data', button_protection=True, pin_protection=True, passphrase_protection=True) self.assertEqual(res, 'random data') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_recoverydevice.py0000644000076500000240000001437512726074236022060 0ustar darinstaff00000000000000from __future__ import print_function import unittest import common from keepkeylib import messages_pb2 as proto class TestDeviceRecovery(common.KeepKeyTest): def test_pin_passphrase(self): mnemonic = self.mnemonic12.split(' ') ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=True, pin_protection=True, label='label', language='english', enforce_wordlist=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for first time pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for second time pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) fakes = 0 for _ in range(int(12 * 2)): self.assertIsInstance(ret, proto.WordRequest) (word, pos) = self.client.debug.read_recovery_word() if pos != 0: ret = self.client.call_raw(proto.WordAck(word=mnemonic[pos - 1])) mnemonic[pos - 1] = None else: ret = self.client.call_raw(proto.WordAck(word=word)) fakes += 1 print(mnemonic) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) # 12 expected fake words and all words of mnemonic are used self.assertEqual(fakes, 12) self.assertEqual(mnemonic, [None] * 12) # Mnemonic is the same self.client.init_device() self.client.clear_session() self.assertEqual(self.client.debug.read_mnemonic(), self.mnemonic12) self.assertTrue(self.client.features.pin_protection) self.assertTrue(self.client.features.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.PassphraseRequest) self.client.call_raw(proto.Cancel()) # Do PIN-protected action, PinRequest should be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) def test_nopin_nopassphrase(self): mnemonic = self.mnemonic12.split(' ') ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True)) fakes = 0 for _ in range(int(12 * 2)): self.assertIsInstance(ret, proto.WordRequest) (word, pos) = self.client.debug.read_recovery_word() if pos != 0: ret = self.client.call_raw(proto.WordAck(word=mnemonic[pos - 1])) mnemonic[pos - 1] = None else: ret = self.client.call_raw(proto.WordAck(word=word)) fakes += 1 print(mnemonic) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) # 12 expected fake words and all words of mnemonic are used self.assertEqual(fakes, 12) self.assertEqual(mnemonic, [None] * 12) # Mnemonic is the same self.client.init_device() self.assertEqual(self.client.debug.read_mnemonic(), self.mnemonic12) self.assertFalse(self.client.features.pin_protection) self.assertFalse(self.client.features.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should NOT be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.Success) # Do PIN-protected action, PinRequest should NOT be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.Success) def test_word_fail(self): ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True)) self.assertIsInstance(ret, proto.WordRequest) for _ in range(int(12 * 2)): (word, pos) = self.client.debug.read_recovery_word() if pos != 0: ret = self.client.call_raw(proto.WordAck(word='kwyjibo')) self.assertIsInstance(ret, proto.Failure) break else: self.client.call_raw(proto.WordAck(word=word)) def test_pin_fail(self): ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=True, pin_protection=True, label='label', language='english', enforce_wordlist=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for first time pin_encoded = self.client.debug.encode_pin(self.pin4) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for second time, but different one pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Failure should be raised self.assertIsInstance(ret, proto.Failure) def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() self.assertRaises(Exception, self.client.recovery_device, 12, False, False, 'label', 'english') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_recoverydevice_cipher.py0000644000076500000240000002710012717427115023376 0ustar darinstaff00000000000000import unittest import common from keepkeylib import messages_pb2 as proto class TestDeviceRecovery(common.KeepKeyTest): def test_pin_passphrase(self): mnemonic = self.mnemonic12 ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=True, pin_protection=True, label='label', language='english', enforce_wordlist=True, use_character_cipher=True)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for first time pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for second time pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) mnemonic_words = mnemonic.split(' ') for index, word in enumerate(mnemonic_words): for character in word: self.assertIsInstance(ret, proto.CharacterRequest) cipher = self.client.debug.read_recovery_cipher() encoded_character = cipher[ord(character) - 97] ret = self.client.call_raw(proto.CharacterAck(character=encoded_character)) auto_completed = self.client.debug.read_recovery_auto_completed_word() if word == auto_completed: if len(mnemonic_words) != index + 1: ret = self.client.call_raw(proto.CharacterAck(character=' ')) break # Send final ack self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(done=True)) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) # Mnemonic is the same self.client.init_device() self.assertEqual(self.client.debug.read_mnemonic(), self.mnemonic12) self.assertTrue(self.client.features.pin_protection) self.assertTrue(self.client.features.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.PassphraseRequest) self.client.call_raw(proto.Cancel()) self.client.clear_session() # Do PIN-protected action, PinRequest should be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) def test_nopin_nopassphrase(self): mnemonic = self.mnemonic12 ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True, use_character_cipher=True)) mnemonic_words = mnemonic.split(' ') for index, word in enumerate(mnemonic_words): for character in word: self.assertIsInstance(ret, proto.CharacterRequest) cipher = self.client.debug.read_recovery_cipher() encoded_character = cipher[ord(character) - 97] ret = self.client.call_raw(proto.CharacterAck(character=encoded_character)) auto_completed = self.client.debug.read_recovery_auto_completed_word() if word == auto_completed: if len(mnemonic_words) != index + 1: ret = self.client.call_raw(proto.CharacterAck(character=' ')) break # Send final ack self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(done=True)) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) # Mnemonic is the same self.client.init_device() self.assertEqual(self.client.debug.read_mnemonic(), self.mnemonic12) self.assertFalse(self.client.features.pin_protection) self.assertFalse(self.client.features.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should NOT be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.Success) # Do PIN-protected action, PinRequest should NOT be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.Success) def test_character_fail(self): ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True, use_character_cipher=True)) self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(character='1')) self.assertIsInstance(ret, proto.Failure) def test_backspace(self): mnemonic = self.mnemonic12 ret = self.client.call_raw(proto.RecoveryDevice(word_count=12, passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True, use_character_cipher=True)) mnemonic_words = mnemonic.split(' ') for index, word in enumerate(mnemonic_words): for character in word: self.assertIsInstance(ret, proto.CharacterRequest) cipher = self.client.debug.read_recovery_cipher() encoded_character = cipher[ord(character) - 97] ret = self.client.call_raw(proto.CharacterAck(character=encoded_character)) auto_completed = self.client.debug.read_recovery_auto_completed_word() if word == auto_completed: if len(mnemonic_words) != index + 1: ret = self.client.call_raw(proto.CharacterAck(character=' ')) break for character in mnemonic: self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(delete=True)) for index, word in enumerate(mnemonic_words): for character in word: self.assertIsInstance(ret, proto.CharacterRequest) cipher = self.client.debug.read_recovery_cipher() encoded_character = cipher[ord(character) - 97] ret = self.client.call_raw(proto.CharacterAck(character=encoded_character)) auto_completed = self.client.debug.read_recovery_auto_completed_word() if word == auto_completed: if len(mnemonic_words) != index + 1: ret = self.client.call_raw(proto.CharacterAck(character=' ')) break # Send final ack self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(done=True)) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) # Mnemonic is the same self.client.init_device() self.assertEqual(self.client.debug.read_mnemonic(), self.mnemonic12) self.assertFalse(self.client.features.pin_protection) self.assertFalse(self.client.features.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should NOT be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.Success) # Do PIN-protected action, PinRequest should NOT be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.Success) def test_reset_and_recover(self): for strength in (128, 192, 256): external_entropy = self.client._get_local_entropy() ret = self.client.call_raw(proto.ResetDevice(display_random=False, strength=strength, passphrase_protection=False, pin_protection=False, language='english', label='test')) # Provide entropy self.assertIsInstance(ret, proto.EntropyRequest) resp = self.client.call_raw(proto.EntropyAck(entropy=external_entropy)) mnemonic = [] while isinstance(resp, proto.ButtonRequest): mnemonic.append(self.client.debug.read_reset_word()) self.client.debug.press_yes() resp = self.client.call_raw(proto.ButtonAck()) mnemonic = ' '.join(mnemonic) # wipe device ret = self.client.call_raw(proto.WipeDevice()) self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) # recover devce ret = self.client.call_raw(proto.RecoveryDevice(word_count=(strength/32*3), passphrase_protection=False, pin_protection=False, label='label', language='english', enforce_wordlist=True, use_character_cipher=True)) mnemonic_words = mnemonic.split(' ') for index, word in enumerate(mnemonic_words): for character in word: self.assertIsInstance(ret, proto.CharacterRequest) cipher = self.client.debug.read_recovery_cipher() encoded_character = cipher[ord(character) - 97] ret = self.client.call_raw(proto.CharacterAck(character=encoded_character)) auto_completed = self.client.debug.read_recovery_auto_completed_word() if word == auto_completed: if len(mnemonic_words) != index + 1: ret = self.client.call_raw(proto.CharacterAck(character=' ')) break # Send final ack self.assertIsInstance(ret, proto.CharacterRequest) ret = self.client.call_raw(proto.CharacterAck(done=True)) # Workflow succesfully ended self.assertIsInstance(ret, proto.Success) self.client.init_device() self.assertEqual(self.client.debug.read_mnemonic(), mnemonic) # wipe device ret = self.client.call_raw(proto.WipeDevice()) self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_resetdevice.py0000644000076500000240000001662412717427115021341 0ustar darinstaff00000000000000import unittest import common import hashlib from keepkeylib import messages_pb2 as proto from mnemonic import Mnemonic def generate_entropy(strength, internal_entropy, external_entropy): ''' strength - length of produced seed. One of 128, 192, 256 random - binary stream of random data from external HRNG ''' if strength not in (128, 192, 256): raise Exception("Invalid strength") if not internal_entropy: raise Exception("Internal entropy is not provided") if len(internal_entropy) < 32: raise Exception("Internal entropy too short") if not external_entropy: raise Exception("External entropy is not provided") if len(external_entropy) < 32: raise Exception("External entropy too short") entropy = hashlib.sha256(internal_entropy + external_entropy).digest() entropy_stripped = entropy[:strength / 8] if len(entropy_stripped) * 8 != strength: raise Exception("Entropy length mismatch") return entropy_stripped class TestDeviceReset(common.KeepKeyTest): def test_reset_device(self): # No PIN, no passphrase external_entropy = 'zlutoucky kun upel divoke ody' * 2 strength = 128 ret = self.client.call_raw(proto.ResetDevice(display_random=False, strength=strength, passphrase_protection=False, pin_protection=False, language='english', label='test')) # Provide entropy self.assertIsInstance(ret, proto.EntropyRequest) internal_entropy = self.client.debug.read_reset_entropy() resp = self.client.call_raw(proto.EntropyAck(entropy=external_entropy)) # Generate mnemonic locally entropy = generate_entropy(strength, internal_entropy, external_entropy) expected_mnemonic = Mnemonic('english').to_mnemonic(entropy) mnemonic = [] while isinstance(resp, proto.ButtonRequest): mnemonic.append(self.client.debug.read_reset_word()) self.client.debug.press_yes() resp = self.client.call_raw(proto.ButtonAck()) mnemonic = ' '.join(mnemonic) # Compare that device generated proper mnemonic for given entropies self.assertEqual(mnemonic, expected_mnemonic) self.assertIsInstance(resp, proto.Success) # Compare that second pass printed out the same mnemonic once again self.assertEqual(mnemonic, expected_mnemonic) # Check if device is properly initialized resp = self.client.call_raw(proto.Initialize()) self.assertFalse(resp.pin_protection) self.assertFalse(resp.passphrase_protection) # Do passphrase-protected action, PassphraseRequest should NOT be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.Success) # Do PIN-protected action, PinRequest should NOT be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.Success) def test_reset_device_pin(self): external_entropy = 'zlutoucky kun upel divoke ody' * 2 strength = 128 ret = self.client.call_raw(proto.ResetDevice(display_random=True, strength=strength, passphrase_protection=True, pin_protection=True, language='english', label='test')) self.assertIsInstance(ret, proto.ButtonRequest) self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for first time pin_encoded = self.client.debug.encode_pin('654') ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for second time pin_encoded = self.client.debug.encode_pin('654') ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) # Provide entropy self.assertIsInstance(ret, proto.EntropyRequest) internal_entropy = self.client.debug.read_reset_entropy() resp = self.client.call_raw(proto.EntropyAck(entropy=external_entropy)) # Generate mnemonic locally entropy = generate_entropy(strength, internal_entropy, external_entropy) expected_mnemonic = Mnemonic('english').to_mnemonic(entropy) mnemonic = [] while isinstance(resp, proto.ButtonRequest): mnemonic.append(self.client.debug.read_reset_word()) self.client.debug.press_yes() resp = self.client.call_raw(proto.ButtonAck()) mnemonic = ' '.join(mnemonic) # Compare that device generated proper mnemonic for given entropies self.assertEqual(mnemonic, expected_mnemonic) self.assertIsInstance(resp, proto.Success) # Compare that second pass printed out the same mnemonic once again self.assertEqual(mnemonic, expected_mnemonic) # Check if device is properly initialized resp = self.client.call_raw(proto.Initialize()) self.assertTrue(resp.pin_protection) self.assertTrue(resp.passphrase_protection) self.client.clear_session() # Do passphrase-protected action, PassphraseRequest should be raised resp = self.client.call_raw(proto.Ping(passphrase_protection=True)) self.assertIsInstance(resp, proto.PassphraseRequest) self.client.call_raw(proto.Cancel()) # Do PIN-protected action, PinRequest should be raised resp = self.client.call_raw(proto.Ping(pin_protection=True)) self.assertIsInstance(resp, proto.PinMatrixRequest) self.client.call_raw(proto.Cancel()) def test_failed_pin(self): external_entropy = 'zlutoucky kun upel divoke ody' * 2 strength = 128 ret = self.client.call_raw(proto.ResetDevice(display_random=True, strength=strength, passphrase_protection=True, pin_protection=True, language='english', label='test')) self.assertIsInstance(ret, proto.ButtonRequest) self.client.debug.press_yes() ret = self.client.call_raw(proto.ButtonAck()) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for first time pin_encoded = self.client.debug.encode_pin(self.pin4) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.PinMatrixRequest) # Enter PIN for second time pin_encoded = self.client.debug.encode_pin(self.pin6) ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) self.assertIsInstance(ret, proto.Failure) def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() self.assertRaises(Exception, self.client.reset_device, False, 128, True, True, 'label', 'english') if __name__ == '__main__': unittest.main() keepkey-0.7.3/tests/test_msg_signidentity.py0000644000076500000240000001032012726074236021536 0ustar darinstaff00000000000000from __future__ import print_function import unittest import common import binascii import hashlib import struct from keepkeylib.client import CallException import keepkeylib.types_pb2 as proto_types def check_path(identity): m = hashlib.sha256() m.update(struct.pack("