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)