Dusan Klinec
13a8a576ed
- Try empty passphrase first when opening a wallet, as all Trezors will have passphrase enabled by default by Trezor Suite by default. This feature enables easier access to all users using disabled passphrase (or empty passhprase) - If wallet address differs from device address with empty passphrase, another opening attempt is made, without passphrase suppression, so user can enter his passhprase if using some. In this scenario, nothing changes to user, wallet opening just consumes one more call to Trezor (get wallet address with empty passphrase) - also change how m_passphrase is used. Previous version did not work well with recent passphrase entry mechanism change (made in Trezor), thus this commit fixes the behaviour).
606 lines
20 KiB
C++
606 lines
20 KiB
C++
// Copyright (c) 2017-2020, The Monero Project
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
// materials provided with the distribution.
|
|
//
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
// used to endorse or promote products derived from this software without specific
|
|
// prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
#include "device_trezor_base.hpp"
|
|
#include "memwipe.h"
|
|
#include <boost/algorithm/string/classification.hpp>
|
|
#include <boost/algorithm/string/split.hpp>
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <boost/regex.hpp>
|
|
|
|
namespace hw {
|
|
namespace trezor {
|
|
|
|
#ifdef WITH_DEVICE_TREZOR
|
|
|
|
#undef MONERO_DEFAULT_LOG_CATEGORY
|
|
#define MONERO_DEFAULT_LOG_CATEGORY "device.trezor"
|
|
#define TREZOR_BIP44_HARDENED_ZERO 0x80000000
|
|
|
|
const uint32_t device_trezor_base::DEFAULT_BIP44_PATH[] = {0x8000002c, 0x80000080};
|
|
|
|
device_trezor_base::device_trezor_base(): m_callback(nullptr), m_last_msg_type(messages::MessageType_Success),
|
|
m_reply_with_empty_passphrase(false),
|
|
m_always_use_empty_passphrase(false),
|
|
m_seen_passphrase_entry_message(false) {
|
|
#ifdef WITH_TREZOR_DEBUGGING
|
|
m_debug = false;
|
|
#endif
|
|
}
|
|
|
|
device_trezor_base::~device_trezor_base() {
|
|
try {
|
|
disconnect();
|
|
release();
|
|
} catch(std::exception const& e){
|
|
MERROR("Could not disconnect and release: " << e.what());
|
|
}
|
|
}
|
|
|
|
/* ======================================================================= */
|
|
/* SETUP/TEARDOWN */
|
|
/* ======================================================================= */
|
|
|
|
bool device_trezor_base::reset() {
|
|
return false;
|
|
}
|
|
|
|
bool device_trezor_base::set_name(const std::string & name) {
|
|
this->m_full_name = name;
|
|
this->name = "";
|
|
|
|
auto delim = name.find(':');
|
|
if (delim != std::string::npos && delim + 1 < name.length()) {
|
|
this->name = name.substr(delim + 1);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const std::string device_trezor_base::get_name() const {
|
|
if (this->m_full_name.empty()) {
|
|
return std::string("<disconnected:").append(this->name).append(">");
|
|
}
|
|
return this->m_full_name;
|
|
}
|
|
|
|
bool device_trezor_base::init() {
|
|
if (!release()){
|
|
MERROR("Release failed");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool device_trezor_base::release() {
|
|
try {
|
|
disconnect();
|
|
return true;
|
|
|
|
} catch(std::exception const& e){
|
|
MERROR("Release exception: " << e.what());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool device_trezor_base::connect() {
|
|
disconnect();
|
|
|
|
// Enumerate all available devices
|
|
TREZOR_AUTO_LOCK_DEVICE();
|
|
try {
|
|
hw::trezor::t_transport_vect trans;
|
|
|
|
MDEBUG("Enumerating Trezor devices...");
|
|
enumerate(trans);
|
|
sort_transports_by_env(trans);
|
|
|
|
MDEBUG("Enumeration yielded " << trans.size() << " Trezor devices");
|
|
for (auto &cur : trans) {
|
|
MDEBUG(" device: " << *(cur.get()));
|
|
}
|
|
|
|
for (auto &cur : trans) {
|
|
std::string cur_path = cur->get_path();
|
|
if (boost::starts_with(cur_path, this->name)) {
|
|
MDEBUG("Device Match: " << cur_path);
|
|
m_transport = cur;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!m_transport) {
|
|
MERROR("No matching Trezor device found. Device specifier: \"" + this->name + "\"");
|
|
return false;
|
|
}
|
|
|
|
m_transport->open();
|
|
|
|
#ifdef WITH_TREZOR_DEBUGGING
|
|
setup_debug();
|
|
#endif
|
|
return true;
|
|
|
|
} catch(std::exception const& e){
|
|
MERROR("Open exception: " << e.what());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool device_trezor_base::disconnect() {
|
|
TREZOR_AUTO_LOCK_DEVICE();
|
|
m_device_session_id.clear();
|
|
m_features.reset();
|
|
m_seen_passphrase_entry_message = false;
|
|
m_reply_with_empty_passphrase = false;
|
|
m_always_use_empty_passphrase = false;
|
|
|
|
if (m_transport){
|
|
try {
|
|
m_transport->close();
|
|
m_transport = nullptr;
|
|
|
|
} catch(std::exception const& e){
|
|
MERROR("Disconnect exception: " << e.what());
|
|
m_transport = nullptr;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#ifdef WITH_TREZOR_DEBUGGING
|
|
if (m_debug_callback) {
|
|
m_debug_callback->on_disconnect();
|
|
m_debug_callback = nullptr;
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
/* ======================================================================= */
|
|
/* LOCKER */
|
|
/* ======================================================================= */
|
|
|
|
//lock the device for a long sequence
|
|
void device_trezor_base::lock() {
|
|
MTRACE("Ask for LOCKING for device " << this->name << " in thread ");
|
|
device_locker.lock();
|
|
MTRACE("Device " << this->name << " LOCKed");
|
|
}
|
|
|
|
//lock the device for a long sequence
|
|
bool device_trezor_base::try_lock() {
|
|
MTRACE("Ask for LOCKING(try) for device " << this->name << " in thread ");
|
|
bool r = device_locker.try_lock();
|
|
if (r) {
|
|
MTRACE("Device " << this->name << " LOCKed(try)");
|
|
} else {
|
|
MDEBUG("Device " << this->name << " not LOCKed(try)");
|
|
}
|
|
return r;
|
|
}
|
|
|
|
//unlock the device
|
|
void device_trezor_base::unlock() {
|
|
MTRACE("Ask for UNLOCKING for device " << this->name << " in thread ");
|
|
device_locker.unlock();
|
|
MTRACE("Device " << this->name << " UNLOCKed");
|
|
}
|
|
|
|
/* ======================================================================= */
|
|
/* Helpers */
|
|
/* ======================================================================= */
|
|
|
|
void device_trezor_base::require_connected() const {
|
|
if (!m_transport){
|
|
throw exc::NotConnectedException();
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::require_initialized() const {
|
|
if (!m_features){
|
|
throw exc::TrezorException("Device state not initialized");
|
|
}
|
|
|
|
if (m_features->has_bootloader_mode() && m_features->bootloader_mode()){
|
|
throw exc::TrezorException("Device is in the bootloader mode");
|
|
}
|
|
|
|
if (m_features->has_firmware_present() && !m_features->firmware_present()){
|
|
throw exc::TrezorException("Device has no firmware loaded");
|
|
}
|
|
|
|
// Hard requirement on initialized field, has to be there.
|
|
if (!m_features->has_initialized() || !m_features->initialized()){
|
|
throw exc::TrezorException("Device is not initialized");
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::call_ping_unsafe(){
|
|
auto pingMsg = std::make_shared<messages::management::Ping>();
|
|
pingMsg->set_message("PING");
|
|
|
|
auto success = this->client_exchange<messages::common::Success>(pingMsg); // messages::MessageType_Success
|
|
MDEBUG("Ping response " << success->message());
|
|
(void)success;
|
|
}
|
|
|
|
void device_trezor_base::test_ping(){
|
|
require_connected();
|
|
|
|
try {
|
|
this->call_ping_unsafe();
|
|
|
|
} catch(exc::TrezorException const& e){
|
|
MINFO("Trezor does not respond: " << e.what());
|
|
throw exc::DeviceNotResponsiveException(std::string("Trezor not responding: ") + e.what());
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::write_raw(const google::protobuf::Message * msg){
|
|
require_connected();
|
|
CHECK_AND_ASSERT_THROW_MES(msg, "Empty message");
|
|
this->get_transport()->write(*msg);
|
|
}
|
|
|
|
GenericMessage device_trezor_base::read_raw(){
|
|
require_connected();
|
|
std::shared_ptr<google::protobuf::Message> msg_resp;
|
|
hw::trezor::messages::MessageType msg_resp_type;
|
|
|
|
this->get_transport()->read(msg_resp, &msg_resp_type);
|
|
return GenericMessage(msg_resp_type, msg_resp);
|
|
}
|
|
|
|
GenericMessage device_trezor_base::call_raw(const google::protobuf::Message * msg) {
|
|
write_raw(msg);
|
|
return read_raw();
|
|
}
|
|
|
|
bool device_trezor_base::message_handler(GenericMessage & input){
|
|
// Later if needed this generic message handler can be replaced by a pointer to
|
|
// a protocol message handler which by default points to the device class which implements
|
|
// the default handler.
|
|
|
|
if (m_last_msg_type == messages::MessageType_ButtonRequest){
|
|
on_button_pressed();
|
|
}
|
|
m_last_msg_type = input.m_type;
|
|
|
|
switch(input.m_type){
|
|
case messages::MessageType_ButtonRequest:
|
|
on_button_request(input, dynamic_cast<const messages::common::ButtonRequest*>(input.m_msg.get()));
|
|
return true;
|
|
case messages::MessageType_PassphraseRequest:
|
|
on_passphrase_request(input, dynamic_cast<const messages::common::PassphraseRequest*>(input.m_msg.get()));
|
|
return true;
|
|
case messages::MessageType_Deprecated_PassphraseStateRequest:
|
|
on_passphrase_state_request(input, dynamic_cast<const messages::common::Deprecated_PassphraseStateRequest*>(input.m_msg.get()));
|
|
return true;
|
|
case messages::MessageType_PinMatrixRequest:
|
|
on_pin_request(input, dynamic_cast<const messages::common::PinMatrixRequest*>(input.m_msg.get()));
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::ensure_derivation_path() noexcept {
|
|
if (m_wallet_deriv_path.empty()){
|
|
m_wallet_deriv_path.push_back(TREZOR_BIP44_HARDENED_ZERO); // default 0'
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::set_derivation_path(const std::string &deriv_path){
|
|
this->m_wallet_deriv_path.clear();
|
|
|
|
if (deriv_path.empty() || deriv_path == "-"){
|
|
ensure_derivation_path();
|
|
return;
|
|
}
|
|
|
|
CHECK_AND_ASSERT_THROW_MES(deriv_path.size() <= 255, "Derivation path is too long");
|
|
|
|
std::vector<std::string> fields;
|
|
boost::split(fields, deriv_path, boost::is_any_of("/"));
|
|
CHECK_AND_ASSERT_THROW_MES(fields.size() <= 10, "Derivation path is too long");
|
|
|
|
boost::regex rgx("^([0-9]+)'?$");
|
|
boost::cmatch match;
|
|
|
|
this->m_wallet_deriv_path.reserve(fields.size());
|
|
for(const std::string & cur : fields){
|
|
const bool ok = boost::regex_match(cur.c_str(), match, rgx);
|
|
CHECK_AND_ASSERT_THROW_MES(ok, "Invalid wallet code: " << deriv_path << ". Invalid path element: " << cur);
|
|
CHECK_AND_ASSERT_THROW_MES(match[0].length() > 0, "Invalid wallet code: " << deriv_path << ". Invalid path element: " << cur);
|
|
|
|
const unsigned long cidx = std::stoul(match[0].str()) | TREZOR_BIP44_HARDENED_ZERO;
|
|
this->m_wallet_deriv_path.push_back((unsigned int)cidx);
|
|
}
|
|
}
|
|
|
|
/* ======================================================================= */
|
|
/* TREZOR PROTOCOL */
|
|
/* ======================================================================= */
|
|
|
|
bool device_trezor_base::ping() {
|
|
TREZOR_AUTO_LOCK_CMD();
|
|
if (!m_transport){
|
|
MINFO("Ping failed, device not connected");
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
this->call_ping_unsafe();
|
|
return true;
|
|
|
|
} catch(std::exception const& e) {
|
|
MERROR("Ping failed, exception thrown " << e.what());
|
|
} catch(...){
|
|
MERROR("Ping failed, general exception thrown" << boost::current_exception_diagnostic_information());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void device_trezor_base::device_state_initialize_unsafe()
|
|
{
|
|
require_connected();
|
|
auto initMsg = std::make_shared<messages::management::Initialize>();
|
|
const auto data_cleaner = epee::misc_utils::create_scope_leave_handler([&]() {
|
|
if (initMsg->has_session_id())
|
|
memwipe(&(*initMsg->mutable_session_id())[0], initMsg->mutable_session_id()->size());
|
|
});
|
|
|
|
if(!m_device_session_id.empty()) {
|
|
initMsg->set_allocated_session_id(new std::string(m_device_session_id.data(), m_device_session_id.size()));
|
|
}
|
|
|
|
m_features = this->client_exchange<messages::management::Features>(initMsg);
|
|
if (m_features->has_session_id()){
|
|
m_device_session_id = m_features->session_id();
|
|
} else {
|
|
m_device_session_id.clear();
|
|
}
|
|
}
|
|
|
|
void device_trezor_base::device_state_reset()
|
|
{
|
|
TREZOR_AUTO_LOCK_CMD();
|
|
device_state_initialize_unsafe();
|
|
}
|
|
|
|
#ifdef WITH_TREZOR_DEBUGGING
|
|
#define TREZOR_CALLBACK(method, ...) do { \
|
|
if (m_debug_callback) m_debug_callback->method(__VA_ARGS__); \
|
|
if (m_callback) m_callback->method(__VA_ARGS__); \
|
|
}while(0)
|
|
#define TREZOR_CALLBACK_GET(VAR, method, ...) do { \
|
|
if (m_debug_callback) VAR = m_debug_callback->method(__VA_ARGS__); \
|
|
if (m_callback) VAR = m_callback->method(__VA_ARGS__); \
|
|
}while(0)
|
|
|
|
void device_trezor_base::setup_debug(){
|
|
if (!m_debug){
|
|
return;
|
|
}
|
|
|
|
if (!m_debug_callback){
|
|
CHECK_AND_ASSERT_THROW_MES(m_transport, "Transport does not exist");
|
|
auto debug_transport = m_transport->find_debug();
|
|
if (debug_transport) {
|
|
m_debug_callback = std::make_shared<trezor_debug_callback>(debug_transport);
|
|
} else {
|
|
MDEBUG("Transport does not have debug link option");
|
|
}
|
|
}
|
|
}
|
|
|
|
#else
|
|
#define TREZOR_CALLBACK(method, ...) do { if (m_callback) m_callback->method(__VA_ARGS__); } while(0)
|
|
#define TREZOR_CALLBACK_GET(VAR, method, ...) VAR = (m_callback ? m_callback->method(__VA_ARGS__) : boost::none)
|
|
#endif
|
|
|
|
void device_trezor_base::on_button_request(GenericMessage & resp, const messages::common::ButtonRequest * msg)
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(msg, "Empty message");
|
|
MDEBUG("on_button_request, code: " << msg->code());
|
|
|
|
TREZOR_CALLBACK(on_button_request, msg->code());
|
|
|
|
messages::common::ButtonAck ack;
|
|
write_raw(&ack);
|
|
|
|
resp = read_raw();
|
|
}
|
|
|
|
void device_trezor_base::on_button_pressed()
|
|
{
|
|
TREZOR_CALLBACK(on_button_pressed);
|
|
}
|
|
|
|
void device_trezor_base::on_pin_request(GenericMessage & resp, const messages::common::PinMatrixRequest * msg)
|
|
{
|
|
MDEBUG("on_pin_request");
|
|
CHECK_AND_ASSERT_THROW_MES(msg, "Empty message");
|
|
|
|
boost::optional<epee::wipeable_string> pin;
|
|
TREZOR_CALLBACK_GET(pin, on_pin_request);
|
|
|
|
if (!pin && m_pin){
|
|
pin = m_pin;
|
|
}
|
|
|
|
messages::common::PinMatrixAck m;
|
|
if (pin) {
|
|
m.set_allocated_pin(new std::string(pin->data(), pin->size()));
|
|
}
|
|
|
|
const auto data_cleaner = epee::misc_utils::create_scope_leave_handler([&]() {
|
|
if (m.has_pin())
|
|
memwipe(&(*m.mutable_pin())[0], m.mutable_pin()->size());
|
|
});
|
|
|
|
resp = call_raw(&m);
|
|
}
|
|
|
|
void device_trezor_base::on_passphrase_request(GenericMessage & resp, const messages::common::PassphraseRequest * msg)
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(msg, "Empty message");
|
|
MDEBUG("on_passhprase_request");
|
|
|
|
// Backward compatibility, migration clause.
|
|
if (msg->has__on_device() && msg->_on_device()){
|
|
messages::common::PassphraseAck m;
|
|
resp = call_raw(&m);
|
|
return;
|
|
}
|
|
|
|
m_seen_passphrase_entry_message = true;
|
|
bool on_device = true;
|
|
if (msg->has__on_device() && !msg->_on_device()){
|
|
on_device = false; // do not enter on device, old devices.
|
|
}
|
|
|
|
if (on_device && m_features && m_features->capabilities_size() > 0){
|
|
on_device = false;
|
|
for (auto it = m_features->capabilities().begin(); it != m_features->capabilities().end(); it++) {
|
|
if (*it == messages::management::Features::Capability_PassphraseEntry){
|
|
on_device = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
boost::optional<epee::wipeable_string> passphrase;
|
|
if (m_reply_with_empty_passphrase || m_always_use_empty_passphrase) {
|
|
MDEBUG("Answering passphrase prompt with an empty passphrase, always use empty: " << m_always_use_empty_passphrase);
|
|
on_device = false;
|
|
passphrase = epee::wipeable_string("");
|
|
} else if (m_passphrase){
|
|
MWARNING("Answering passphrase prompt with a stored passphrase (do not use; passphrase can be seen by a potential malware / attacker)");
|
|
on_device = false;
|
|
passphrase = epee::wipeable_string(m_passphrase.get());
|
|
} else {
|
|
TREZOR_CALLBACK_GET(passphrase, on_passphrase_request, on_device);
|
|
}
|
|
|
|
messages::common::PassphraseAck m;
|
|
m.set_on_device(on_device);
|
|
if (!on_device) {
|
|
if (passphrase) {
|
|
m.set_allocated_passphrase(new std::string(passphrase->data(), passphrase->size()));
|
|
}
|
|
}
|
|
|
|
const auto data_cleaner = epee::misc_utils::create_scope_leave_handler([&]() {
|
|
if (m.has_passphrase())
|
|
memwipe(&(*m.mutable_passphrase())[0], m.mutable_passphrase()->size());
|
|
});
|
|
|
|
resp = call_raw(&m);
|
|
}
|
|
|
|
void device_trezor_base::on_passphrase_state_request(GenericMessage & resp, const messages::common::Deprecated_PassphraseStateRequest * msg)
|
|
{
|
|
MDEBUG("on_passhprase_state_request");
|
|
CHECK_AND_ASSERT_THROW_MES(msg, "Empty message");
|
|
|
|
if (msg->has_state()) {
|
|
m_device_session_id = msg->state();
|
|
}
|
|
messages::common::Deprecated_PassphraseStateAck m;
|
|
resp = call_raw(&m);
|
|
}
|
|
|
|
#ifdef WITH_TREZOR_DEBUGGING
|
|
void device_trezor_base::wipe_device()
|
|
{
|
|
auto msg = std::make_shared<messages::management::WipeDevice>();
|
|
auto ret = client_exchange<messages::common::Success>(msg);
|
|
(void)ret;
|
|
init_device();
|
|
}
|
|
|
|
void device_trezor_base::init_device()
|
|
{
|
|
auto msg = std::make_shared<messages::management::Initialize>();
|
|
m_features = client_exchange<messages::management::Features>(msg);
|
|
}
|
|
|
|
void device_trezor_base::load_device(const std::string & mnemonic, const std::string & pin,
|
|
bool passphrase_protection, const std::string & label, const std::string & language,
|
|
bool skip_checksum, bool expand)
|
|
{
|
|
if (m_features && m_features->initialized()){
|
|
throw std::runtime_error("Device is initialized already. Call device.wipe() and try again.");
|
|
}
|
|
|
|
auto msg = std::make_shared<messages::management::LoadDevice>();
|
|
msg->add_mnemonics(mnemonic);
|
|
msg->set_pin(pin);
|
|
msg->set_passphrase_protection(passphrase_protection);
|
|
msg->set_label(label);
|
|
msg->set_language(language);
|
|
msg->set_skip_checksum(skip_checksum);
|
|
auto ret = client_exchange<messages::common::Success>(msg);
|
|
(void)ret;
|
|
|
|
init_device();
|
|
}
|
|
|
|
trezor_debug_callback::trezor_debug_callback(std::shared_ptr<Transport> & debug_transport){
|
|
m_debug_link = std::make_shared<DebugLink>();
|
|
m_debug_link->init(debug_transport);
|
|
}
|
|
|
|
void trezor_debug_callback::on_button_request(uint64_t code) {
|
|
if (m_debug_link) m_debug_link->press_yes();
|
|
}
|
|
|
|
boost::optional<epee::wipeable_string> trezor_debug_callback::on_pin_request() {
|
|
return boost::none;
|
|
}
|
|
|
|
boost::optional<epee::wipeable_string> trezor_debug_callback::on_passphrase_request(bool & on_device) {
|
|
on_device = true;
|
|
return boost::none;
|
|
}
|
|
|
|
void trezor_debug_callback::on_passphrase_state_request(const std::string &state) {
|
|
|
|
}
|
|
|
|
void trezor_debug_callback::on_disconnect(){
|
|
if (m_debug_link) m_debug_link->close();
|
|
}
|
|
#endif
|
|
|
|
#endif //WITH_DEVICE_TREZOR
|
|
}}
|