1
0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-12-17 11:58:13 +00:00
trezor-firmware/firmware/fsm.c

254 lines
6.5 KiB
C
Raw Normal View History

2014-04-29 12:26:51 +00:00
/*
* This file is part of the TREZOR project, https://trezor.io/
2014-04-29 12:26:51 +00:00
*
* Copyright (C) 2014 Pavol Rusnak <stick@satoshilabs.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/>.
*/
2017-10-03 11:11:53 +00:00
#include <libopencm3/stm32/flash.h>
2014-04-29 12:26:51 +00:00
#include "trezor.h"
#include "fsm.h"
#include "messages.h"
#include "bip32.h"
2019-01-25 10:58:23 +00:00
#include "config.h"
2014-04-29 12:26:51 +00:00
#include "coins.h"
#include "debug.h"
#include "transaction.h"
#include "rng.h"
#include "oled.h"
#include "protect.h"
#include "pinmatrix.h"
#include "layout2.h"
2017-01-02 20:22:59 +00:00
#include "address.h"
#include "base58.h"
2014-04-29 12:26:51 +00:00
#include "ecdsa.h"
#include "reset.h"
#include "recovery.h"
#include "memory.h"
#include "usb.h"
#include "util.h"
#include "signing.h"
#include "aes/aes.h"
2014-06-07 12:21:59 +00:00
#include "hmac.h"
#include "crypto.h"
#include "base58.h"
2014-12-08 18:58:13 +00:00
#include "bip39.h"
2016-04-22 15:49:00 +00:00
#include "curves.h"
#include "secp256k1.h"
2016-05-24 21:22:30 +00:00
#include "ethereum.h"
2017-05-29 16:07:55 +00:00
#include "nem.h"
2017-05-30 16:41:02 +00:00
#include "nem2.h"
2017-10-03 11:11:53 +00:00
#include "rfc6979.h"
#include "gettext.h"
#include "supervise.h"
2018-08-27 14:41:56 +00:00
#include "messages.pb.h"
2018-09-14 10:13:41 +00:00
#include "stellar.h"
#include "lisk.h"
#include "memzero.h"
2014-04-29 12:26:51 +00:00
// message methods
2016-08-29 21:22:49 +00:00
static uint8_t msg_resp[MSG_OUT_SIZE] __attribute__ ((aligned));
2014-04-29 12:26:51 +00:00
#define RESP_INIT(TYPE) \
TYPE *resp = (TYPE *) (void *) msg_resp; \
_Static_assert(sizeof(msg_resp) >= sizeof(TYPE), #TYPE " is too large"); \
memzero(resp, sizeof(TYPE));
2014-04-29 12:26:51 +00:00
#define CHECK_INITIALIZED \
2019-01-25 10:58:23 +00:00
if (!config_isInitialized()) { \
fsm_sendFailure(FailureType_Failure_NotInitialized, NULL); \
return; \
}
#define CHECK_NOT_INITIALIZED \
2019-01-25 10:58:23 +00:00
if (config_isInitialized()) { \
fsm_sendFailure(FailureType_Failure_UnexpectedMessage, _("Device is already initialized. Use Wipe first.")); \
return; \
}
#define CHECK_PIN \
if (!protectPin(true)) { \
layoutHome(); \
return; \
}
#define CHECK_PIN_UNCACHED \
if (!protectPin(false)) { \
layoutHome(); \
return; \
}
2016-11-22 20:39:33 +00:00
#define CHECK_PARAM(cond, errormsg) \
if (!(cond)) { \
fsm_sendFailure(FailureType_Failure_DataError, (errormsg)); \
2016-11-22 20:39:33 +00:00
layoutHome(); \
return; \
}
2014-04-29 12:26:51 +00:00
void fsm_sendSuccess(const char *text)
{
RESP_INIT(Success);
if (text) {
resp->has_message = true;
strlcpy(resp->message, text, sizeof(resp->message));
}
msg_write(MessageType_MessageType_Success, resp);
}
#if DEBUG_LINK
void fsm_sendFailureDebug(FailureType code, const char *text, const char *source)
#else
void fsm_sendFailure(FailureType code, const char *text)
#endif
2014-04-29 12:26:51 +00:00
{
if (protectAbortedByCancel) {
protectAbortedByCancel = false;
}
if (protectAbortedByInitialize) {
fsm_msgInitialize((Initialize *)0);
protectAbortedByInitialize = false;
return;
}
2014-04-29 12:26:51 +00:00
RESP_INIT(Failure);
resp->has_code = true;
resp->code = code;
if (!text) {
switch (code) {
case FailureType_Failure_UnexpectedMessage:
text = _("Unexpected message");
break;
case FailureType_Failure_ButtonExpected:
text = _("Button expected");
break;
case FailureType_Failure_DataError:
text = _("Data error");
break;
case FailureType_Failure_ActionCancelled:
text = _("Action cancelled by user");
break;
case FailureType_Failure_PinExpected:
text = _("PIN expected");
break;
case FailureType_Failure_PinCancelled:
text = _("PIN cancelled");
break;
case FailureType_Failure_PinInvalid:
text = _("PIN invalid");
break;
case FailureType_Failure_InvalidSignature:
text = _("Invalid signature");
break;
case FailureType_Failure_ProcessError:
text = _("Process error");
break;
case FailureType_Failure_NotEnoughFunds:
text = _("Not enough funds");
break;
case FailureType_Failure_NotInitialized:
text = _("Device not initialized");
break;
case FailureType_Failure_PinMismatch:
text = _("PIN mismatch");
break;
case FailureType_Failure_FirmwareError:
text = _("Firmware error");
break;
}
}
#if DEBUG_LINK
resp->has_message = true;
strlcpy(resp->message, source, sizeof(resp->message));
if (text) {
strlcat(resp->message, text, sizeof(resp->message));
}
#else
2014-04-29 12:26:51 +00:00
if (text) {
resp->has_message = true;
strlcpy(resp->message, text, sizeof(resp->message));
}
#endif
2014-04-29 12:26:51 +00:00
msg_write(MessageType_MessageType_Failure, resp);
}
static const CoinInfo *fsm_getCoin(bool has_name, const char *name)
2015-01-26 11:51:56 +00:00
{
const CoinInfo *coin;
if (has_name) {
coin = coinByName(name);
} else {
coin = coinByName("Bitcoin");
}
2015-01-26 11:51:56 +00:00
if (!coin) {
fsm_sendFailure(FailureType_Failure_DataError, _("Invalid coin name"));
2015-01-26 11:51:56 +00:00
layoutHome();
return 0;
}
return coin;
}
static HDNode *fsm_getDerivedNode(const char *curve, const uint32_t *address_n, size_t address_n_count, uint32_t *fingerprint)
2014-04-29 12:26:51 +00:00
{
static CONFIDENTIAL HDNode node;
if (fingerprint) {
*fingerprint = 0;
}
2019-01-25 10:58:23 +00:00
if (!config_getRootNode(&node, curve, true)) {
fsm_sendFailure(FailureType_Failure_NotInitialized, _("Device not initialized or passphrase request cancelled or unsupported curve"));
2015-01-26 11:51:56 +00:00
layoutHome();
2014-04-29 12:26:51 +00:00
return 0;
}
if (!address_n || address_n_count == 0) {
return &node;
}
if (hdnode_private_ckd_cached(&node, address_n, address_n_count, fingerprint) == 0) {
fsm_sendFailure(FailureType_Failure_ProcessError, _("Failed to derive private key"));
layoutHome();
return 0;
2014-04-29 12:26:51 +00:00
}
return &node;
2014-04-29 12:26:51 +00:00
}
static bool fsm_layoutAddress(const char *address, const char *desc, bool ignorecase, size_t prefixlen, const uint32_t *address_n, size_t address_n_count, bool address_is_account)
{
bool qrcode = false;
for (;;) {
const char* display_addr = address;
if (prefixlen && !qrcode) {
display_addr += prefixlen;
}
layoutAddress(display_addr, desc, qrcode, ignorecase, address_n, address_n_count, address_is_account);
if (protectButton(ButtonRequestType_ButtonRequest_Address, false)) {
return true;
}
if (protectAbortedByCancel || protectAbortedByInitialize) {
fsm_sendFailure(FailureType_Failure_ActionCancelled, NULL);
layoutHome();
return false;
}
qrcode = !qrcode;
}
}
#include "fsm_msg_common.h"
#include "fsm_msg_coin.h"
#include "fsm_msg_ethereum.h"
#include "fsm_msg_crypto.h"
#include "fsm_msg_nem.h"
#include "fsm_msg_stellar.h"
2018-09-14 10:13:41 +00:00
#include "fsm_msg_lisk.h"
#include "fsm_msg_debug.h"