async def change_pin(ctx, msg):
# confirm that user wants to change the pin
await confirm_change_pin(ctx, msg)
# get current pin, return failure if invalid
if config.has_pin():
curpin = await request_pin_ack(ctx, PinMatrixRequestType.Current)
if not config.check_pin(pin_to_int(curpin), show_pin_timeout):
return Failure(code=FailureType.PinInvalid, message='PIN invalid')
else:
curpin = ''
# get new pin
if not msg.remove:
newpin = await request_pin_confirm(ctx)
else:
newpin = ''
# write into storage
if config.change_pin(pin_to_int(curpin), pin_to_int(newpin),
show_pin_timeout):
if newpin:
return Success(message='PIN changed')
else:
return Success(message='PIN removed')
else:
return Failure(code=FailureType.PinInvalid, message='PIN invalid')
def failure(exc: BaseException) -> Failure:
if isinstance(exc, Error):
return Failure(code=exc.code, message=exc.message)
elif isinstance(exc, loop.TaskClosed):
return Failure(code=FailureType.ActionCancelled, message="Cancelled")
else:
return Failure(code=FailureType.FirmwareError, message="Firmware error")
async def protobuf_workflow(ctx: Context, reader: codec_v1.Reader,
handler: Handler, *args: Any) -> None:
from trezor.messages.Failure import Failure
req = await protobuf.load_message(reader, messages.get_type(reader.type))
if __debug__:
log.debug(__name__, "%s:%x request: %s", ctx.iface.iface_num(),
ctx.sid, req)
try:
res = await handler(ctx, req, *args)
except UnexpectedMessageError:
# session handler takes care of this one
raise
except Error as exc:
# respond with specific code and message
await ctx.write(Failure(code=exc.code, message=exc.message))
raise
except Exception as e:
# respond with a generic code and message
message = "Firmware error"
if __debug__:
message = "{}: {}".format(type(e), e)
await ctx.write(
Failure(code=FailureType.FirmwareError, message=message))
raise
if res:
# respond with a specific response
await ctx.write(res)
async def get_nonce_public(ctx, msg):
idx = msg.slot
if idx == get_master_nonce_idx() or idx > 255:
return Failure(message='Incorrect slot provided')
if not is_master_nonce_created():
return Failure(message='Nonce Generator is not initialized')
pubkey_x, pubkey_y = get_nonce_pub(msg.slot)
return BeamECCPoint(x=pubkey_x, y=int(pubkey_y[0]))
async def generate_nonce(ctx, msg):
gc.collect()
idx = msg.slot
if idx == get_master_nonce_idx() or idx > 255:
return Failure(message="Incorrect slot provided")
if not is_master_nonce_created():
return Failure(message="Nonce Generator is not initialized")
_, new_nonce = create_nonce(idx)
pubkey_x, pubkey_y = calc_nonce_pub(new_nonce)
return BeamECCPoint(x=pubkey_x, y=int(pubkey_y[0]))
async def _wrap_protobuf_workflow(wf, session_id):
try:
result = await wf
except CloseWorkflow:
return
except FailureError as e:
await write(session_id, e.to_protobuf())
raise
except Exception as e:
from trezor.messages.Failure import Failure
from trezor.messages.FailureType import FirmwareError
await write(session_id,
Failure(code=FirmwareError, message='Firmware Error'))
raise
else:
if result is not None:
await write(session_id, result)
return result
finally:
if session_id in sessions.opened:
sessions.listen(session_id, _handle_workflow)
async def get_owner_key(ctx, msg):
if not config.has_pin():
return Failure(message='PIN is not set')
label = "Enter your PIN"
while True:
try:
pin = await ctx.wait(request_pin(label))
if config.unlock(pin_to_int(pin)):
break
else:
label = "Wrong PIN, enter again"
except PinCancelled:
raise wire.ActionCancelled("Cancelled")
export_warning_msg = 'Exposing the key to a third party allows them to see your balance.'
await beam_confirm_message(ctx, 'Owner key', export_warning_msg, False)
wait_warning_msg = 'Please wait few seconds until exporting is done'
await beam_confirm_message(ctx, 'Owner key', wait_warning_msg, False)
pin = pin.encode()
owner_key = generate_owner_key(pin)
if msg.show_display:
await beam_confirm_message(ctx, 'Owner key', owner_key, True)
return BeamOwnerKey(key=owner_key)
async def unexpected_msg(ctx, reader):
from trezor.messages.Failure import Failure
# receive the message and throw it away
while reader.size > 0:
buf = bytearray(reader.size)
await reader.areadinto(buf)
# respond with an unknown message error
await ctx.write(Failure(code=FailureType.UnexpectedMessage, message='Unexpected message'))
async def unexpected_msg(ctx: Context, reader: codec_v1.Reader) -> None:
from trezor.messages.Failure import Failure
# receive the message and throw it away
await read_full_msg(reader)
# respond with an unknown message error
await ctx.write(
Failure(code=FailureType.UnexpectedMessage,
message="Unexpected message"))
def _handle_unexpected(session_id, msg_type, data_len):
log.warning(__name__, 'session %x: skip type %d, len %d', session_id,
msg_type, data_len)
# read the message in full
try:
while True:
yield
except EOFError:
pass
# respond with an unknown message error
from trezor.messages.Failure import Failure
from trezor.messages.FailureType import UnexpectedMessage
failure = Failure(code=UnexpectedMessage, message='Unexpected message')
failure = Failure.dumps(failure)
sessions.get_codec(session_id).encode(session_id,
Failure.MESSAGE_WIRE_TYPE, failure,
_write_report)
async def protobuf_workflow(ctx, reader, handler, *args):
from trezor.messages.Failure import Failure
req = await protobuf.load_message(reader, messages.get_type(reader.type))
try:
res = await handler(ctx, req, *args)
except UnexpectedMessageError:
# session handler takes care of this one
raise
except Error as exc:
# respond with specific code and message
await ctx.write(Failure(code=exc.code, message=exc.message))
raise
except Exception as exc:
# respond with a generic code and message
await ctx.write(Failure(code=FailureType.FirmwareError, message='Firmware error'))
raise
if res:
# respond with a specific response
await ctx.write(res)
async def cardano_verify_message(ctx, msg):
try:
res = _verify_message(msg.public_key, msg.signature, msg.message)
except ValueError as e:
if __debug__:
log.exception(__name__, e)
raise wire.ProcessError("Verifying failed")
if not res:
return Failure(message="Invalid signature")
if not await show_swipable_with_confirmation(
ctx, msg.message, "Verifying message", ui.ICON_RECEIVE, ui.GREEN):
raise wire.ActionCancelled("Verifying cancelled")
if not await show_swipable_with_confirmation(ctx, hexlify(
msg.public_key), "With public key", ui.ICON_RECEIVE, ui.GREEN):
raise wire.ActionCancelled("Verifying cancelled")
return Success(message="Message verified")
async def layout_change_pin(ctx, msg):
from trezor.messages.Success import Success
from trezor.messages.Failure import Failure
from trezor.messages import FailureType, PinMatrixRequestType
await confirm_change_pin(ctx, msg)
if config.has_pin():
curr_pin = await request_pin(ctx, PinMatrixRequestType.Current)
else:
curr_pin = ''
if msg.remove:
new_pin = ''
else:
new_pin = await request_pin_confirm(ctx)
if config.change_pin(pin_to_int(curr_pin), pin_to_int(new_pin), show_pin_timeout):
if new_pin:
return Success(message='PIN changed')
else:
return Success(message='PIN removed')
else:
return Failure(code=FailureType.PinInvalid, message='PIN invalid')
async def verify_message(ctx, msg):
await paths.validate_path(ctx, validate_full_path, path=msg.address_n)
try:
res = _verify_message(msg.public_key, msg.signature, msg.message)
except ValueError as e:
if __debug__:
log.exception(__name__, e)
raise wire.ProcessError("Verifying failed")
if not res:
return Failure(message="Invalid signature")
if not await confirm_with_pagination(ctx, msg.message, "Verifying message",
ui.ICON_RECEIVE, ui.GREEN):
raise wire.ActionCancelled("Verifying cancelled")
if not await confirm_with_pagination(ctx, hexlify(
msg.public_key), "With public key", ui.ICON_RECEIVE, ui.GREEN):
raise wire.ActionCancelled("Verifying cancelled")
return Success(message="Message verified")
def unexpected_message() -> Failure:
return Failure(code=FailureType.UnexpectedMessage,
message="Unexpected message")
def retit(**kwargs):
from trezor.messages.Failure import Failure
return Failure(**kwargs)
def failure(exc: BaseException) -> Failure:
if isinstance(exc, Error):
return Failure(code=exc.code, message=exc.message)
else:
return Failure(code=FailureType.FirmwareError,
message="Firmware error")
def to_protobuf(self):
from trezor.messages.Failure import Failure
code, message = self.args
return Failure(code=code, message=message)