2015-05-12 23:55:39 +00:00
#!/usr/bin/env python
2016-11-25 21:53:55 +00:00
# This file is part of the TREZOR project.
#
# Copyright (C) 2012-2016 Marek Palatinus <slush@satoshilabs.com>
# Copyright (C) 2012-2016 Pavol Rusnak <stick@satoshilabs.com>
# Copyright (C) 2016 Jochen Hoenicke <hoenicke@gmail.com>
#
# This library is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this library. If not, see <http://www.gnu.org/licenses/>.
2016-05-20 20:27:20 +00:00
from __future__ import print_function
2016-06-29 20:40:37 +00:00
import sys
2015-02-22 13:23:39 +00:00
import binascii
import argparse
import json
import base64
2016-05-20 14:08:55 +00:00
from io import BytesIO
2015-02-22 13:23:39 +00:00
2017-07-01 15:59:11 +00:00
from trezorlib.client import TrezorClient, TrezorClientVerbose, CallException
2016-06-29 20:40:37 +00:00
import trezorlib.types_pb2 as types
2015-02-22 13:23:39 +00:00
2017-07-01 15:59:11 +00:00
2016-05-27 07:05:54 +00:00
ether_units = {
"wei": 1,
"kwei": 1000,
"babbage": 1000,
"femtoether": 1000,
"mwei": 1000000,
"lovelace": 1000000,
"picoether": 1000000,
"gwei": 1000000000,
"shannon": 1000000000,
"nanoether": 1000000000,
"nano": 1000000000,
"szabo": 1000000000000,
"microether": 1000000000000,
"micro": 1000000000000,
"finney": 1000000000000000,
"milliether": 1000000000000000,
"milli": 1000000000000000,
"ether": 1000000000000000000,
"eth": 1000000000000000000,
}
2017-07-01 15:59:11 +00:00
2016-09-28 12:34:50 +00:00
def init_parser(commands):
2016-02-10 15:46:58 +00:00
parser = argparse.ArgumentParser(description='Commandline tool for TREZOR devices.')
2015-02-22 13:23:39 +00:00
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='Prints communication to device')
2016-06-30 14:23:07 +00:00
parser.add_argument('-t', '--transport', dest='transport', choices=['usb', 'udp', 'pipe', 'bridge'], default='usb', help="Transport used for talking with the device")
2016-11-11 18:18:52 +00:00
parser.add_argument('-p', '--path', dest='path', default='', help="Path used by the transport")
2015-02-22 13:23:39 +00:00
parser.add_argument('-j', '--json', dest='json', action='store_true', help="Prints result as json object")
cmdparser = parser.add_subparsers(title='Available commands')
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
for cmd in commands._list_commands():
func = object.__getattribute__(commands, cmd)
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
try:
arguments = func.arguments
except AttributeError:
arguments = ((('params',), {'nargs': '*'}),)
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
item = cmdparser.add_parser(cmd, help=func.help)
for arg in arguments:
item.add_argument(*arg[0], **arg[1])
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
item.set_defaults(func=func)
item.set_defaults(cmd=cmd)
2015-09-04 18:41:54 +00:00
2016-09-28 12:34:50 +00:00
return parser
2015-02-22 13:23:39 +00:00
2017-07-01 15:59:11 +00:00
def get_transport_class_by_name(name):
2015-02-22 13:23:39 +00:00
2017-07-01 15:59:11 +00:00
if name == 'usb':
from trezorlib.transport_hid import HidTransport
return HidTransport
2015-09-04 18:41:54 +00:00
2017-07-01 15:59:11 +00:00
if name == 'udp':
2016-04-30 00:37:18 +00:00
from trezorlib.transport_udp import UdpTransport
2017-07-01 15:59:11 +00:00
return UdpTransport
2016-04-30 00:37:18 +00:00
2017-07-01 15:59:11 +00:00
if name == 'pipe':
2015-02-22 13:23:39 +00:00
from trezorlib.transport_pipe import PipeTransport
2017-07-01 15:59:11 +00:00
return PipeTransport
2015-09-04 18:41:54 +00:00
2017-07-01 15:59:11 +00:00
if name == 'bridge':
2015-02-22 13:23:39 +00:00
from trezorlib.transport_bridge import BridgeTransport
2017-07-01 15:59:11 +00:00
return BridgeTransport
raise NotImplementedError('Unknown transport: "%s"' % name)
2016-06-30 14:47:17 +00:00
2017-07-01 15:59:11 +00:00
def get_transport(transport_name, path):
transport = get_transport_class_by_name(transport_name)
dev = transport.find_by_path(path)
return dev
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
class Commands(object):
def __init__(self, client):
self.client = client
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
@classmethod
def _list_commands(cls):
2016-05-26 15:20:44 +00:00
return [x for x in dir(cls) if not x.startswith('_')]
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
def list(self, args):
# Fake method for advertising 'list' command
pass
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
def get_address(self, args):
address_n = self.client.expand_path(args.n)
2017-01-02 20:25:07 +00:00
typemap = { 'address': types.SPENDADDRESS,
'segwit': types.SPENDWITNESS,
'p2shsegwit': types.SPENDP2SHWITNESS }
script_type = typemap[args.script_type];
return self.client.get_address(args.coin, address_n, args.show_display, script_type=script_type)
2015-09-04 18:41:54 +00:00
2016-05-26 06:47:04 +00:00
def ethereum_get_address(self, args):
2016-05-24 19:32:58 +00:00
address_n = self.client.expand_path(args.n)
2016-05-26 06:47:04 +00:00
address = self.client.ethereum_get_address(address_n, args.show_display)
return "0x%s" % (binascii.hexlify(address),)
2016-05-24 19:32:58 +00:00
2016-07-02 18:26:58 +00:00
def ethereum_sign_tx(self, args):
2016-05-27 07:05:54 +00:00
from ethjsonrpc import EthJsonRpc
from ethjsonrpc.utils import hex_to_dec
import rlp
value = args.value
if ' ' in value:
value, unit = value.split(' ', 1)
if unit.lower() not in ether_units:
2017-06-18 21:14:28 +00:00
raise CallException(types.Failure_DataError, "Unrecognized ether unit %r" % unit)
2016-05-27 07:05:54 +00:00
value = int(value) * ether_units[unit.lower()]
else:
value = int(value)
2016-12-01 14:23:38 +00:00
gas_price = args.gas_price
2017-01-22 17:58:29 +00:00
if gas_price is not None:
2016-12-01 14:23:38 +00:00
if ' ' in gas_price:
gas_price, unit = gas_price.split(' ', 1)
if unit.lower() not in ether_units:
2017-06-18 21:14:28 +00:00
raise CallException(types.Failure_DataError, "Unrecognized gas price unit %r" % unit)
2016-12-01 14:23:38 +00:00
gas_price = int(gas_price) * ether_units[unit.lower()]
else:
gas_price = int(gas_price)
gas_limit = args.gas
2017-01-22 17:58:29 +00:00
if gas_limit is not None:
2016-12-01 14:23:38 +00:00
gas_limit = int(gas_limit)
2016-05-27 07:05:54 +00:00
if args.to.startswith('0x') or args.to.startswith('0X'):
to_address = args.to[2:].decode('hex')
else:
to_address = args.to.decode('hex')
2016-12-01 14:23:38 +00:00
nonce = args.nonce
if nonce:
nonce = int(nonce)
2016-05-27 07:05:54 +00:00
address_n = self.client.expand_path(args.n)
address = "0x%s" % (binascii.hexlify(self.client.ethereum_get_address(address_n)),)
2017-01-22 17:58:29 +00:00
if gas_price is None or gas_limit is None or nonce is None:
2016-12-01 14:23:38 +00:00
host, port = args.host.split(':')
eth = EthJsonRpc(host, int(port))
2016-05-27 07:05:54 +00:00
2017-01-22 12:51:07 +00:00
if not args.data:
2017-01-22 17:58:29 +00:00
args.data = ''
elif args.data.startswith('0x'):
2016-08-22 23:14:23 +00:00
args.data = args.data[2:]
2016-08-19 21:05:54 +00:00
data = binascii.unhexlify(args.data)
2016-12-01 14:23:38 +00:00
2017-01-22 17:58:29 +00:00
if gas_price is None:
2016-12-01 14:23:38 +00:00
gas_price = eth.eth_gasPrice()
2017-01-22 17:58:29 +00:00
if gas_limit is None:
2017-01-22 12:51:07 +00:00
gas_limit = eth.eth_estimateGas(
2016-05-27 07:05:54 +00:00
to_address=args.to,
from_address=address,
2017-01-22 12:51:07 +00:00
value=("0x%x" % value),
data="0x"+args.data)
2016-12-01 14:23:38 +00:00
2017-01-22 17:58:29 +00:00
if nonce is None:
2016-12-01 14:23:38 +00:00
nonce = eth.eth_getTransactionCount(address)
2016-05-27 07:05:54 +00:00
sig = self.client.ethereum_sign_tx(
n=address_n,
nonce=nonce,
gas_price=gas_price,
gas_limit=gas_limit,
to=to_address,
value=value,
2017-01-22 12:51:07 +00:00
data=data,
chain_id=args.chain_id)
2016-05-27 07:05:54 +00:00
transaction = rlp.encode(
2016-08-22 23:14:23 +00:00
(nonce, gas_price, gas_limit, to_address, value, data) + sig)
2016-07-02 18:26:58 +00:00
tx_hex = '0x%s' % binascii.hexlify(transaction)
if args.publish:
tx_hash = eth.eth_sendRawTransaction(tx_hex)
return 'Transaction published with ID: %s' % tx_hash
else:
return 'Signed raw transaction: %s' % tx_hex
2016-05-27 07:05:54 +00:00
2015-02-22 13:23:39 +00:00
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):
2016-05-26 15:20:44 +00:00
return [coin.coin_name for coin in self.client.features.coins]
2015-02-22 13:23:39 +00:00
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)
2017-04-24 14:31:18 +00:00
return self.client.get_public_node(address_n, ecdsa_curve_name=args.curve, show_display=args.show_display, coin_name=args.coin)
2015-09-04 18:41:54 +00:00
2017-02-23 10:56:54 +00:00
def enable_passphrase(self, args):
return self.client.apply_settings(use_passphrase=True)
def disable_passphrase(self, args):
return self.client.apply_settings(use_passphrase=False)
2015-02-22 13:23:39 +00:00
def set_label(self, args):
return self.client.apply_settings(label=args.label)
2016-05-26 15:20:44 +00:00
def set_homescreen(self, args):
2015-02-22 13:23:39 +00:00
if args.filename:
from PIL import Image
im = Image.open(args.filename)
2016-05-26 15:20:44 +00:00
if im.size != (128, 64):
2017-06-18 21:14:28 +00:00
raise CallException(types.Failure_DataError, 'Wrong size of the image')
2015-02-22 13:23:39 +00:00
im = im.convert('1')
pix = im.load()
img = ''
for j in range(64):
for i in range(128):
img += '1' if pix[i, j] else '0'
img = ''.join(chr(int(img[i:i + 8], 2)) for i in range(0, len(img), 8))
else:
img = '\x00'
return self.client.apply_settings(homescreen=img)
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):
2016-11-23 12:55:08 +00:00
typemap = { 'scrambled': types.RecoveryDeviceType_ScrambledWords,
2016-06-29 20:40:37 +00:00
'matrix': types.RecoveryDeviceType_Matrix }
2015-02-22 13:23:39 +00:00
return self.client.recovery_device(args.words, args.passphrase_protection,
2016-11-23 12:55:08 +00:00
args.pin_protection, args.label, 'english',
2017-06-21 14:29:49 +00:00
typemap[args.type], args.expand, args.dry_run)
2015-02-22 13:23:39 +00:00
def load_device(self, args):
if not args.mnemonic and not args.xprv:
2017-06-18 21:14:28 +00:00
raise CallException(types.Failure_DataError, "Please provide mnemonic or xprv")
2015-02-22 13:23:39 +00:00
if args.mnemonic:
mnemonic = ' '.join(args.mnemonic)
return self.client.load_device_by_mnemonic(mnemonic, args.pin,
2016-05-26 15:20:44 +00:00
args.passphrase_protection,
args.label, 'english',
2017-02-11 19:15:09 +00:00
args.skip_checksum,
args.expand)
2015-02-22 13:23:39 +00:00
else:
return self.client.load_device_by_xprv(args.xprv, args.pin,
2016-05-26 15:20:44 +00:00
args.passphrase_protection,
args.label, 'english')
2015-02-22 13:23:39 +00:00
def reset_device(self, args):
return self.client.reset_device(True, args.strength, args.passphrase_protection,
2017-06-23 17:23:08 +00:00
args.pin_protection, args.label, 'english',
args.u2f_counter, args.skip_backup)
def backup_device(self, args):
return self.client.backup_device()
2015-02-22 13:23:39 +00:00
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)
2016-10-10 09:01:40 +00:00
return self.client.verify_message(args.coin, args.address, signature, args.message)
2015-02-22 13:23:39 +00:00
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
2016-06-12 21:49:52 +00:00
def set_u2f_counter(self, args):
ret = self.client.set_u2f_counter(args.counter)
return ret
2017-07-03 16:49:03 +00:00
def self_test(self, args):
ret = self.client.self_test()
return ret
2015-02-22 13:23:39 +00:00
def firmware_update(self, args):
2015-04-02 17:05:51 +00:00
if args.file:
2016-05-20 15:20:11 +00:00
fp = open(args.file, 'rb').read()
2015-04-02 17:05:51 +00:00
elif args.url:
2016-10-03 08:42:02 +00:00
import requests
2016-05-20 11:36:17 +00:00
print("Downloading from", args.url)
2016-05-20 14:08:55 +00:00
r = requests.get(args.url)
fp = r.content
2015-09-04 18:41:54 +00:00
else:
2016-10-03 08:42:02 +00:00
import requests
2016-08-10 14:51:06 +00:00
r = requests.get('https://wallet.trezor.io/data/firmware/releases.json')
2016-05-20 14:08:55 +00:00
releases = r.json()
2015-09-04 18:41:54 +00:00
version = lambda r: r['version']
version_string = lambda r: ".".join(map(str, version(r)))
if args.version:
release = next((r for r in releases if version_string(r) == args.version))
else:
release = max(releases, key=version)
2016-05-20 11:36:17 +00:00
print("No file, url, or version given. Fetching latest version: %s" % version_string(release))
print("Firmware fingerprint: %s" % release['fingerprint'])
2016-08-10 14:51:06 +00:00
args.url = 'https://wallet.trezor.io/' + release['url']
2015-09-04 18:41:54 +00:00
return self.firmware_update(args)
2016-09-26 10:28:06 +00:00
if not args.skip_check:
2017-06-20 15:17:33 +00:00
if fp[:8] == b'54525a52' or fp[:8] == b'54525a56':
2016-09-26 10:28:06 +00:00
fp = binascii.unhexlify(fp)
2017-06-20 15:17:33 +00:00
if fp[:4] != b'TRZR' and fp[:4] != b'TRZV':
2016-09-27 22:01:32 +00:00
raise CallException(types.Failure_FirmwareError, "TREZOR firmware header expected")
2015-02-22 13:23:39 +00:00
2016-05-20 11:36:17 +00:00
print("Please confirm action on device...")
2015-04-09 19:13:35 +00:00
2016-05-20 14:08:55 +00:00
return self.client.firmware_update(fp=BytesIO(fp))
2015-02-22 13:23:39 +00:00
2016-02-10 15:46:58 +00:00
list.help = 'List connected TREZOR USB devices'
2015-02-22 13:23:39 +00:00
ping.help = 'Send ping message'
get_address.help = 'Get bitcoin address in base58 encoding'
2016-05-26 06:47:04 +00:00
ethereum_get_address.help = 'Get Ethereum address in hex encoding'
2016-07-02 18:26:58 +00:00
ethereum_sign_tx.help = 'Sign (and optionally publish) Ethereum transaction'
2015-02-22 13:23:39 +00:00
get_entropy.help = 'Get example entropy'
get_features.help = 'Retrieve device features and settings'
get_public_node.help = 'Get public node of given path'
2017-02-23 10:56:54 +00:00
enable_passphrase.help = 'Enable passphrase'
disable_passphrase.help = 'Disable passphrase'
2015-02-22 13:23:39 +00:00
set_label.help = 'Set new wallet label'
set_homescreen.help = 'Set new homescreen'
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'
2017-06-23 17:23:08 +00:00
backup_device.help = 'Perform device seed backup'
2015-02-22 13:23:39 +00:00
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'
2016-06-12 21:49:52 +00:00
set_u2f_counter.help = 'Set U2F counter'
2017-07-03 16:49:03 +00:00
self_test.help = 'Perform a self-test'
2015-02-22 13:23:39 +00:00
firmware_update.help = 'Upload new firmware to device (must be in bootloader mode)'
2016-11-01 12:20:37 +00:00
clear_session.arguments= ()
2015-02-22 13:23:39 +00:00
get_address.arguments = (
(('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}),
(('-n', '-address'), {'type': str}),
2017-01-02 20:25:07 +00:00
(('-t', '--script-type'), {'type': str, 'choices': ['address', 'segwit', 'p2shsegwit'], 'default': 'address'}),
2015-02-22 13:23:39 +00:00
(('-d', '--show-display'), {'action': 'store_true', 'default': False}),
)
2015-09-04 18:41:54 +00:00
2016-05-26 06:47:04 +00:00
ethereum_get_address.arguments = (
2016-05-24 19:32:58 +00:00
(('-n', '-address'), {'type': str}),
(('-d', '--show-display'), {'action': 'store_true', 'default': False}),
)
2016-07-02 18:26:58 +00:00
ethereum_sign_tx.arguments = (
2017-01-22 17:58:29 +00:00
(('-a', '--host'), {'type': str, 'help': 'RPC port of ethereum node for automatic gas/nonce estimation', 'default': 'localhost:8545'}),
2017-01-22 12:51:07 +00:00
(('-c', '--chain-id'), {'type' : int, 'help': 'EIP-155 chain id (replay protection)', 'default': None}),
2017-01-22 17:58:29 +00:00
(('-n', '-address'), {'type': str, 'help': 'BIP-32 path to signing key'}),
(('-v', '--value'), {'type': str, 'help': 'Ether amount to transfer, e.g., "100 milliether"', 'default': "0"}),
(('-g', '--gas'), {'type': int, 'help': 'Gas limit - Required for offline signing', 'default': None}),
(('-t', '--gas-price'), {'type': str, 'help': 'Gas price, e.g., "20 nanoether" - Required for offline signing', 'default': None }),
(('-i', '--nonce'), {'type': int, 'help': 'Transaction counter - Required for offline signing', 'default': None}),
(('-d', '--data'), {'type': str, 'help': 'Data as hex string, e.g., 0x12345678', 'default': ''}),
(('-p', '--publish'), {'action': 'store_true', 'help': 'publish transaction via RPC', 'default': False}),
(('to',), {'type': str, 'help': 'Destination address; "" for contract creation'}),
2016-05-27 07:05:54 +00:00
)
2015-02-22 13:23:39 +00:00
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}),
)
2015-09-04 18:41:54 +00:00
2017-02-23 10:56:54 +00:00
enable_passphrase.arguments = ()
disable_passphrase.arguments = ()
2015-02-22 13:23:39 +00:00
set_label.arguments = (
(('-l', '--label',), {'type': str, 'default': ''}),
2016-05-26 15:20:44 +00:00
# (('-c', '--clear'), {'action': 'store_true', 'default': False})
2015-02-22 13:23:39 +00:00
)
set_homescreen.arguments = (
(('-f', '--filename',), {'type': str, 'default': ''}),
)
change_pin.arguments = (
2016-05-26 15:20:44 +00:00
(('-r', '--remove'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
wipe_device.arguments = ()
recovery_device.arguments = (
2016-11-01 12:20:37 +00:00
(('-w', '--words'), {'type': int, 'choices': [12, 18, 24], 'default': 24}),
2017-02-11 19:15:09 +00:00
(('-e', '--expand'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
(('-p', '--pin-protection'), {'action': 'store_true', 'default': False}),
(('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}),
(('-l', '--label'), {'type': str, 'default': ''}),
2016-12-08 14:36:51 +00:00
(('-t', '--type'), {'type': str, 'choices': ['scrambled', 'matrix'], 'default': 'scrambled'}),
2017-06-21 14:29:49 +00:00
(('-d', '--dry-run'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
load_device.arguments = (
(('-m', '--mnemonic'), {'type': str, 'nargs': '+'}),
2017-02-11 19:15:09 +00:00
(('-e', '--expand'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
(('-x', '--xprv'), {'type': str}),
(('-p', '--pin'), {'type': str, 'default': ''}),
(('-r', '--passphrase-protection'), {'action': 'store_true', 'default': False}),
(('-l', '--label'), {'type': str, 'default': ''}),
2015-10-19 17:48:14 +00:00
(('-s', '--skip-checksum'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
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': ''}),
2017-06-23 17:23:08 +00:00
(('-u', '--u2f-counter'), {'type': int, 'default': 0}),
(('-s', '--skip-backup'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
2017-06-23 17:23:08 +00:00
backup_device.arguments = ()
2015-02-22 13:23:39 +00:00
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 = (
2016-10-10 09:01:40 +00:00
(('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}),
2015-02-22 13:23:39 +00:00
(('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 = (
2017-04-24 14:31:18 +00:00
(('-c', '--coin'), {'type': str, 'default': 'Bitcoin'}),
2015-02-22 13:23:39 +00:00
(('-n', '-address'), {'type': str}),
2016-05-19 09:56:38 +00:00
(('-e', '--curve'), {'type': str}),
2015-11-19 10:47:19 +00:00
(('-d', '--show-display'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
2016-06-12 21:49:52 +00:00
set_u2f_counter.arguments = (
(('counter',), {'type': int}),
)
2017-07-03 16:49:03 +00:00
self_test.arguments = ()
2015-02-22 13:23:39 +00:00
firmware_update.arguments = (
(('-f', '--file'), {'type': str}),
2015-04-02 17:05:51 +00:00
(('-u', '--url'), {'type': str}),
2015-09-04 18:41:54 +00:00
(('-n', '--version'), {'type': str}),
2016-09-26 10:28:06 +00:00
(('-s', '--skip-check'), {'action': 'store_true', 'default': False}),
2015-02-22 13:23:39 +00:00
)
def list_usb():
from trezorlib.transport_hid import HidTransport
return HidTransport.enumerate()
def main():
2016-09-28 12:34:50 +00:00
parser = init_parser(Commands)
args = parser.parse_args()
if not hasattr(args, 'cmd'):
parser.print_help()
exit(0)
2015-02-22 13:23:39 +00:00
2016-09-27 22:01:32 +00:00
try:
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:
2017-07-01 15:59:11 +00:00
client = TrezorClientVerbose(transport)
2015-02-22 13:23:39 +00:00
else:
2016-09-27 22:01:32 +00:00
client = TrezorClient(transport)
2015-02-22 13:23:39 +00:00
2016-09-27 22:01:32 +00:00
cmds = Commands(client)
2015-09-04 18:41:54 +00:00
2016-09-27 22:01:32 +00:00
res = args.func(cmds, args)
if args.json:
print(json.dumps(res, sort_keys=True, indent=4))
else:
print(res)
except CallException as e:
status, message = e.args
2017-06-23 15:05:47 +00:00
sys.stderr.write('Failure: ')
2017-06-20 14:36:40 +00:00
sys.stderr.write(str(message))
2017-06-23 15:05:47 +00:00
sys.stderr.write('\n')
2016-09-27 22:01:32 +00:00
exit(status)
2015-09-04 18:41:54 +00:00
2015-02-22 13:23:39 +00:00
if __name__ == '__main__':
main()
2017-07-01 15:59:11 +00:00