1
0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-12-05 22:18:16 +00:00
trezor-firmware/legacy/firmware/protect.c

438 lines
13 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/>.
*/
#include "protect.h"
#include "buttons.h"
2019-01-25 10:58:23 +00:00
#include "config.h"
#include "debug.h"
#include "fsm.h"
#include "gettext.h"
#include "layout2.h"
#include "memory.h"
#include "memzero.h"
2014-04-29 12:26:51 +00:00
#include "messages.h"
#include "messages.pb.h"
2014-04-29 12:26:51 +00:00
#include "oled.h"
#include "pinmatrix.h"
#include "usb.h"
2014-04-29 12:26:51 +00:00
#include "util.h"
#define MAX_WRONG_PINS 15
bool protectAbortedByCancel = false;
bool protectAbortedByInitialize = false;
bool protectButton(ButtonRequestType type, bool confirm_only) {
ButtonRequest resp = {0};
bool result = false;
bool acked = false;
#if DEBUG_LINK
bool debug_decided = false;
#endif
2014-04-29 12:26:51 +00:00
memzero(&resp, sizeof(ButtonRequest));
resp.has_code = true;
resp.code = type;
usbTiny(1);
buttonUpdate(); // Clear button state
msg_write(MessageType_MessageType_ButtonRequest, &resp);
for (;;) {
usbPoll();
// check for ButtonAck
if (msg_tiny_id == MessageType_MessageType_ButtonAck) {
msg_tiny_id = 0xFFFF;
acked = true;
}
// button acked - check buttons
if (acked) {
waitAndProcessUSBRequests(5);
buttonUpdate();
if (button.YesUp) {
result = true;
break;
}
if (!confirm_only && button.NoUp) {
result = false;
break;
}
}
// check for Cancel / Initialize
protectAbortedByCancel = (msg_tiny_id == MessageType_MessageType_Cancel);
protectAbortedByInitialize =
(msg_tiny_id == MessageType_MessageType_Initialize);
if (protectAbortedByCancel || protectAbortedByInitialize) {
msg_tiny_id = 0xFFFF;
result = false;
break;
}
2014-04-29 12:26:51 +00:00
#if DEBUG_LINK
// check DebugLink
if (msg_tiny_id == MessageType_MessageType_DebugLinkDecision) {
msg_tiny_id = 0xFFFF;
DebugLinkDecision *dld = (DebugLinkDecision *)msg_tiny;
result = dld->button;
debug_decided = true;
}
if (acked && debug_decided) {
break;
}
if (msg_tiny_id == MessageType_MessageType_DebugLinkGetState) {
msg_tiny_id = 0xFFFF;
fsm_msgDebugLinkGetState((DebugLinkGetState *)msg_tiny);
}
2014-04-29 12:26:51 +00:00
#endif
}
2014-04-29 12:26:51 +00:00
usbTiny(0);
2014-04-29 12:26:51 +00:00
return result;
2014-04-29 12:26:51 +00:00
}
const char *requestPin(PinMatrixRequestType type, const char *text) {
PinMatrixRequest resp = {0};
memzero(&resp, sizeof(PinMatrixRequest));
resp.has_type = true;
resp.type = type;
usbTiny(1);
msg_write(MessageType_MessageType_PinMatrixRequest, &resp);
pinmatrix_start(text);
for (;;) {
usbPoll();
if (msg_tiny_id == MessageType_MessageType_PinMatrixAck) {
msg_tiny_id = 0xFFFF;
PinMatrixAck *pma = (PinMatrixAck *)msg_tiny;
usbTiny(0);
2020-03-13 14:34:07 +00:00
if (sectrue == pinmatrix_done(pma->pin)) // convert via pinmatrix
return pma->pin;
else
return 0;
}
// check for Cancel / Initialize
protectAbortedByCancel = (msg_tiny_id == MessageType_MessageType_Cancel);
protectAbortedByInitialize =
(msg_tiny_id == MessageType_MessageType_Initialize);
if (protectAbortedByCancel || protectAbortedByInitialize) {
pinmatrix_done(0);
msg_tiny_id = 0xFFFF;
usbTiny(0);
return 0;
}
2014-04-29 12:26:51 +00:00
#if DEBUG_LINK
if (msg_tiny_id == MessageType_MessageType_DebugLinkGetState) {
msg_tiny_id = 0xFFFF;
fsm_msgDebugLinkGetState((DebugLinkGetState *)msg_tiny);
}
2014-04-29 12:26:51 +00:00
#endif
}
2014-04-29 12:26:51 +00:00
}
secbool protectPinUiCallback(uint32_t wait, uint32_t progress,
enum storage_ui_message_t message) {
// Convert wait to secstr string.
char secstrbuf[] = _("________0 seconds");
char *secstr = secstrbuf + 9;
uint32_t secs = wait;
do {
secstr--;
*secstr = (secs % 10) + '0';
secs /= 10;
} while (secs > 0 && secstr >= secstrbuf);
if (wait == 1) {
// Change "seconds" to "second".
secstrbuf[16] = 0;
}
oledClear();
const char *message_str = NULL;
switch (message) {
case VERIFYING_PIN_MSG:
message_str = _("Verifying PIN");
break;
case PROCESSING_MSG:
message_str = _("Processing");
break;
case STARTING_MSG:
message_str = _("Starting up");
break;
case WRONG_PIN_MSG:
message_str = _("Wrong PIN");
break;
default:
message_str = _("");
break;
}
oledDrawStringCenter(OLED_WIDTH / 2, 0 * 9, message_str, FONT_STANDARD);
oledDrawStringCenter(OLED_WIDTH / 2, 2 * 9, _("Please wait"), FONT_STANDARD);
oledDrawStringCenter(OLED_WIDTH / 2, 3 * 9, secstr, FONT_STANDARD);
oledDrawStringCenter(OLED_WIDTH / 2, 4 * 9, _("to continue ..."),
FONT_STANDARD);
// progressbar
oledFrame(0, OLED_HEIGHT - 8, OLED_WIDTH - 1, OLED_HEIGHT - 1);
oledBox(1, OLED_HEIGHT - 7, OLED_WIDTH - 2, OLED_HEIGHT - 2, 0);
progress = progress * (OLED_WIDTH - 4) / 1000;
if (progress > OLED_WIDTH - 4) {
progress = OLED_WIDTH - 4;
}
oledBox(2, OLED_HEIGHT - 6, 1 + progress, OLED_HEIGHT - 3, 1);
oledRefresh();
// Check for Cancel / Initialize.
protectAbortedByCancel = (msg_tiny_id == MessageType_MessageType_Cancel);
protectAbortedByInitialize =
(msg_tiny_id == MessageType_MessageType_Initialize);
if (protectAbortedByCancel || protectAbortedByInitialize) {
msg_tiny_id = 0xFFFF;
usbTiny(0);
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return sectrue;
}
return secfalse;
}
bool protectPin(bool use_cached) {
if (use_cached && session_isUnlocked()) {
return true;
}
const char *pin = "";
if (config_hasPin()) {
pin = requestPin(PinMatrixRequestType_PinMatrixRequestType_Current,
_("Please enter current PIN:"));
if (!pin) {
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return false;
}
}
bool ret = config_unlock(pin);
if (!ret) {
fsm_sendFailure(FailureType_Failure_PinInvalid, NULL);
}
return ret;
2014-04-29 12:26:51 +00:00
}
bool protectChangePin(bool removal) {
static CONFIDENTIAL char old_pin[MAX_PIN_LEN + 1] = "";
static CONFIDENTIAL char new_pin[MAX_PIN_LEN + 1] = "";
const char *pin = NULL;
if (config_hasPin()) {
pin = requestPin(PinMatrixRequestType_PinMatrixRequestType_Current,
_("Please enter current PIN:"));
if (pin == NULL) {
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return false;
}
// If removing, defer the check to config_changePin().
if (!removal) {
usbTiny(1);
bool ret = config_unlock(pin);
usbTiny(0);
if (ret == false) {
fsm_sendFailure(FailureType_Failure_PinInvalid, NULL);
return false;
}
}
strlcpy(old_pin, pin, sizeof(old_pin));
}
if (!removal) {
pin = requestPin(PinMatrixRequestType_PinMatrixRequestType_NewFirst,
_("Please enter new PIN:"));
2020-03-13 14:34:07 +00:00
if (pin == NULL || pin[0] == '\0') {
memzero(old_pin, sizeof(old_pin));
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return false;
}
strlcpy(new_pin, pin, sizeof(new_pin));
pin = requestPin(PinMatrixRequestType_PinMatrixRequestType_NewSecond,
_("Please re-enter new PIN:"));
if (pin == NULL) {
memzero(old_pin, sizeof(old_pin));
memzero(new_pin, sizeof(new_pin));
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return false;
}
if (strncmp(new_pin, pin, sizeof(new_pin)) != 0) {
memzero(old_pin, sizeof(old_pin));
memzero(new_pin, sizeof(new_pin));
fsm_sendFailure(FailureType_Failure_PinMismatch, NULL);
return false;
}
}
bool ret = config_changePin(old_pin, new_pin);
memzero(old_pin, sizeof(old_pin));
memzero(new_pin, sizeof(new_pin));
if (ret == false) {
if (removal) {
fsm_sendFailure(FailureType_Failure_PinInvalid, NULL);
} else {
fsm_sendFailure(FailureType_Failure_ProcessError,
_("The new PIN must be different from your wipe code."));
}
}
return ret;
}
bool protectChangeWipeCode(bool removal) {
static CONFIDENTIAL char pin[MAX_PIN_LEN + 1] = "";
static CONFIDENTIAL char wipe_code[MAX_PIN_LEN + 1] = "";
const char *input = NULL;
if (config_hasPin()) {
input = requestPin(PinMatrixRequestType_PinMatrixRequestType_Current,
_("Please enter your PIN:"));
if (input == NULL) {
fsm_sendFailure(FailureType_Failure_PinCancelled, NULL);
return false;
}
// If removing, defer the check to config_changeWipeCode().
if (!removal) {
usbTiny(1);
bool ret = config_unlock(input);
usbTiny(0);
if (ret == false) {
fsm_sendFailure(FailureType_Failure_PinInvalid, NULL);
return false;
}
}
strlcpy(pin, input, sizeof(pin));
}
if (!removal) {
input = requestPin(PinMatrixRequestType_PinMatrixRequestType_WipeCodeFirst,
_("Enter new wipe code:"));
if (input == NULL) {
memzero(pin, sizeof(pin));
fsm_sendFailure(FailureType_Failure_ActionCancelled, NULL);
return false;
}
if (strncmp(pin, input, sizeof(pin)) == 0) {
memzero(pin, sizeof(pin));
fsm_sendFailure(FailureType_Failure_ProcessError,
_("The wipe code must be different from your PIN."));
return false;
}
strlcpy(wipe_code, input, sizeof(wipe_code));
input = requestPin(PinMatrixRequestType_PinMatrixRequestType_WipeCodeSecond,
_("Re-enter new wipe code:"));
if (input == NULL) {
memzero(pin, sizeof(pin));
memzero(wipe_code, sizeof(wipe_code));
fsm_sendFailure(FailureType_Failure_ActionCancelled, NULL);
return false;
}
if (strncmp(wipe_code, input, sizeof(wipe_code)) != 0) {
memzero(pin, sizeof(pin));
memzero(wipe_code, sizeof(wipe_code));
fsm_sendFailure(FailureType_Failure_WipeCodeMismatch, NULL);
return false;
}
}
bool ret = config_changeWipeCode(pin, wipe_code);
memzero(pin, sizeof(pin));
memzero(wipe_code, sizeof(wipe_code));
if (ret == false) {
fsm_sendFailure(FailureType_Failure_PinInvalid, NULL);
}
return ret;
2014-04-29 12:26:51 +00:00
}
2020-01-20 14:00:07 +00:00
bool protectPassphrase(char *passphrase) {
memzero(passphrase, MAX_PASSPHRASE_LEN + 1);
bool passphrase_protection = false;
config_getPassphraseProtection(&passphrase_protection);
2020-01-20 14:00:07 +00:00
if (!passphrase_protection) {
// passphrase already set to empty by memzero above
return true;
}
PassphraseRequest resp = {0};
memzero(&resp, sizeof(PassphraseRequest));
usbTiny(1);
msg_write(MessageType_MessageType_PassphraseRequest, &resp);
layoutDialogSwipe(&bmp_icon_info, NULL, NULL, NULL, _("Please enter your"),
_("passphrase using"), _("the computer's"), _("keyboard."),
NULL, NULL);
bool result;
for (;;) {
usbPoll();
if (msg_tiny_id == MessageType_MessageType_PassphraseAck) {
msg_tiny_id = 0xFFFF;
PassphraseAck *ppa = (PassphraseAck *)msg_tiny;
2020-01-19 10:08:53 +00:00
if (ppa->has_on_device && ppa->on_device == true) {
fsm_sendFailure(
FailureType_Failure_DataError,
_("This firmware is incapable of passphrase entry on the device."));
2020-01-20 10:22:08 +00:00
result = false;
break;
}
if (!ppa->has_passphrase) {
fsm_sendFailure(FailureType_Failure_DataError,
_("No passphrase provided. Use empty string to set an "
"empty passphrase."));
result = false;
break;
2020-01-19 10:08:53 +00:00
}
2020-01-20 14:00:07 +00:00
strlcpy(passphrase, ppa->passphrase, sizeof(ppa->passphrase));
result = true;
break;
}
// check for Cancel / Initialize
protectAbortedByCancel = (msg_tiny_id == MessageType_MessageType_Cancel);
protectAbortedByInitialize =
(msg_tiny_id == MessageType_MessageType_Initialize);
if (protectAbortedByCancel || protectAbortedByInitialize) {
fsm_sendFailure(FailureType_Failure_ActionCancelled, NULL);
result = false;
msg_tiny_id = 0xFFFF;
break;
}
#if DEBUG_LINK
if (msg_tiny_id == MessageType_MessageType_DebugLinkGetState) {
msg_tiny_id = 0xFFFF;
fsm_msgDebugLinkGetState((DebugLinkGetState *)msg_tiny);
}
#endif
}
usbTiny(0);
layoutHome();
return result;
2014-04-29 12:26:51 +00:00
}