Electroneum
device_trezor_base.hpp
Go to the documentation of this file.
1 // Copyright (c) 2017-Present, Electroneum
2 //
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without modification, are
6 // permitted provided that the following conditions are met:
7 //
8 // 1. Redistributions of source code must retain the above copyright notice, this list of
9 // conditions and the following disclaimer.
10 //
11 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 // of conditions and the following disclaimer in the documentation and/or other
13 // materials provided with the distribution.
14 //
15 // 3. Neither the name of the copyright holder nor the names of its contributors may be
16 // used to endorse or promote products derived from this software without specific
17 // prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
20 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
22 // THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
27 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29 
30 #ifndef ELECTRONEUM_DEVICE_TREZOR_BASE_H
31 #define ELECTRONEUM_DEVICE_TREZOR_BASE_H
32 
33 
34 #include <cstddef>
35 #include <string>
36 #include "device/device.hpp"
38 #include "device/device_cold.hpp"
39 #include <boost/scope_exit.hpp>
40 #include <boost/thread/mutex.hpp>
41 #include <boost/thread/recursive_mutex.hpp>
42 #include "cryptonote_config.h"
43 #include "trezor.hpp"
44 
45 #ifdef WITH_TREZOR_DEBUGGING
46 #include "trezor/debug_link.hpp"
47 #endif
48 
49 //automatic lock one more level on device ensuring the current thread is allowed to use it
50 #define TREZOR_AUTO_LOCK_CMD() \
51  /* lock both mutexes without deadlock*/ \
52  boost::lock(device_locker, command_locker); \
53  /* make sure both already-locked mutexes are unlocked at the end of scope */ \
54  boost::lock_guard<boost::recursive_mutex> lock1(device_locker, boost::adopt_lock); \
55  boost::lock_guard<boost::mutex> lock2(command_locker, boost::adopt_lock)
56 
57 #define TREZOR_AUTO_LOCK_DEVICE() boost::lock_guard<boost::recursive_mutex> lock1_device(device_locker)
58 
59 namespace hw {
60 namespace trezor {
61 
62 #ifdef WITH_DEVICE_TREZOR
63  class device_trezor_base;
64 
65 #ifdef WITH_TREZOR_DEBUGGING
66  class trezor_debug_callback : public hw::i_device_callback {
67  public:
68  trezor_debug_callback()=default;
69  explicit trezor_debug_callback(std::shared_ptr<Transport> & debug_transport);
70 
71  void on_button_request(uint64_t code=0) override;
72  boost::optional<epee::wipeable_string> on_pin_request() override;
73  boost::optional<epee::wipeable_string> on_passphrase_request(bool on_device) override;
74  void on_passphrase_state_request(const std::string &state);
75  void on_disconnect();
76  protected:
77  std::shared_ptr<DebugLink> m_debug_link;
78  };
79 
80 #endif
81 
85  class device_trezor_base : public hw::core::device_default {
86  protected:
87 
88  // Locker for concurrent access
89  mutable boost::recursive_mutex device_locker;
90  mutable boost::mutex command_locker;
91 
92  std::shared_ptr<Transport> m_transport;
93  i_device_callback * m_callback;
94 
95  std::string m_full_name;
96  std::vector<unsigned int> m_wallet_deriv_path;
97  std::string m_device_state; // returned after passphrase entry, session
98  std::shared_ptr<messages::management::Features> m_features; // features from the last device reset
99  boost::optional<epee::wipeable_string> m_pin;
100  boost::optional<epee::wipeable_string> m_passphrase;
101  messages::MessageType m_last_msg_type;
102 
104 
105 #ifdef WITH_TREZOR_DEBUGGING
106  std::shared_ptr<trezor_debug_callback> m_debug_callback;
107  bool m_debug;
108 
109  void setup_debug();
110 #endif
111 
112  //
113  // Internal methods
114  //
115 
116  void require_connected() const;
117  void require_initialized() const;
118  void call_ping_unsafe();
119  void test_ping();
120  virtual void device_state_reset_unsafe();
121  void ensure_derivation_path() noexcept;
122 
123  // Communication methods
124 
125  void write_raw(const google::protobuf::Message * msg);
126  GenericMessage read_raw();
127  GenericMessage call_raw(const google::protobuf::Message * msg);
128 
129  // Trezor message protocol handler. Handles specific signalling messages.
130  bool message_handler(GenericMessage & input);
131 
138  template<class t_message=google::protobuf::Message>
139  std::shared_ptr<t_message>
140  client_exchange(const std::shared_ptr<const google::protobuf::Message> &req,
141  const boost::optional<messages::MessageType> & resp_type = boost::none,
142  const boost::optional<std::vector<messages::MessageType>> & resp_types = boost::none,
143  const boost::optional<messages::MessageType*> & resp_type_ptr = boost::none,
144  bool open_session = false)
145  {
146  // Require strictly protocol buffers response in the template.
149  if (resp_types && !accepting_base){
150  throw std::invalid_argument("Cannot specify list of accepted types and not using generic response");
151  }
152 
153  // Determine type of expected message response
154  const messages::MessageType required_type = accepting_base ? messages::MessageType_Success :
155  (resp_type ? resp_type.get() : MessageMapper::get_message_wire_number<t_message>());
156 
157  // Open session if required
158  if (open_session){
159  try {
160  m_transport->open();
161  } catch (const std::exception& e) {
162  std::throw_with_nested(exc::SessionException("Could not open session"));
163  }
164  }
165 
166  // Scoped session closer
167  BOOST_SCOPE_EXIT_ALL(&, this) {
168  if (open_session){
169  this->get_transport()->close();
170  }
171  };
172 
173  // Write/read the request
174  CHECK_AND_ASSERT_THROW_MES(req, "Request is null");
175  auto msg_resp = call_raw(req.get());
176 
177  bool processed = false;
178  do {
179  processed = message_handler(msg_resp);
180  } while(processed);
181 
182  // Response section
183  if (resp_type_ptr){
184  *(resp_type_ptr.get()) = msg_resp.m_type;
185  }
186 
187  if (msg_resp.m_type == messages::MessageType_Failure) {
188  throw_failure_exception(dynamic_cast<messages::common::Failure *>(msg_resp.m_msg.get()));
189 
190  } else if (!accepting_base && msg_resp.m_type == required_type) {
191  return message_ptr_retype<t_message>(msg_resp.m_msg);
192 
193  } else if (accepting_base && (!resp_types ||
194  std::find(resp_types.get().begin(), resp_types.get().end(), msg_resp.m_type) != resp_types.get().end())) {
195  return message_ptr_retype<t_message>(msg_resp.m_msg);
196 
197  } else {
198  throw exc::UnexpectedMessageException(msg_resp.m_type, msg_resp.m_msg);
199  }
200  }
201 
205  template<class t_message>
206  void set_msg_addr(t_message * msg,
207  const boost::optional<std::vector<uint32_t>> & path = boost::none,
208  const boost::optional<cryptonote::network_type> & network_type = boost::none)
209  {
210  CHECK_AND_ASSERT_THROW_MES(msg, "Message is null");
211  msg->clear_address_n();
212  if (path){
213  for(auto x : path.get()){
214  msg->add_address_n(x);
215  }
216  } else {
217  ensure_derivation_path();
218  for (unsigned int i : DEFAULT_BIP44_PATH) {
219  msg->add_address_n(i);
220  }
221  for (unsigned int i : m_wallet_deriv_path) {
222  msg->add_address_n(i);
223  }
224  }
225 
226  if (network_type){
227  msg->set_network_type(static_cast<uint32_t>(network_type.get()));
228  } else {
229  msg->set_network_type(static_cast<uint32_t>(this->network_type));
230  }
231  }
232 
233  public:
234  device_trezor_base();
235  ~device_trezor_base() override;
236 
237  device_trezor_base(const device_trezor_base &device) = delete ;
238  device_trezor_base& operator=(const device_trezor_base &device) = delete;
239 
240  explicit operator bool() const override {return true;}
241  device_type get_type() const override {return device_type::TREZOR;};
242 
243  bool reset();
244 
245  // Default derivation path for Electroneum
246  static const uint32_t DEFAULT_BIP44_PATH[2];
247 
248  std::shared_ptr<Transport> get_transport(){
249  return m_transport;
250  }
251 
252  void set_callback(i_device_callback * callback) override {
253  m_callback = callback;
254  }
255 
256  i_device_callback * get_callback(){
257  return m_callback;
258  }
259 
260  std::shared_ptr<messages::management::Features> & get_features() {
261  return m_features;
262  }
263 
264  uint64_t get_version() const {
265  CHECK_AND_ASSERT_THROW_MES(m_features, "Features not loaded");
266  CHECK_AND_ASSERT_THROW_MES(m_features->has_major_version() && m_features->has_minor_version() && m_features->has_patch_version(), "Invalid Trezor firmware version information");
267  return pack_version(m_features->major_version(), m_features->minor_version(), m_features->patch_version());
268  }
269 
270  void set_derivation_path(const std::string &deriv_path) override;
271 
272  virtual bool has_ki_live_refresh(void) const override { return false; }
273 
274  virtual void set_pin(const epee::wipeable_string & pin) override {
275  m_pin = pin;
276  }
277  virtual void set_passphrase(const epee::wipeable_string & passphrase) override {
278  m_passphrase = passphrase;
279  }
280 
281  /* ======================================================================= */
282  /* SETUP/TEARDOWN */
283  /* ======================================================================= */
284  bool set_name(const std::string &name) override;
285 
286  const std::string get_name() const override;
287  bool init() override;
288  bool release() override;
289  bool connect() override;
290  bool disconnect() override;
291 
292  /* ======================================================================= */
293  /* LOCKER */
294  /* ======================================================================= */
295  void lock() override;
296  void unlock() override;
297  bool try_lock() override;
298 
299  /* ======================================================================= */
300  /* TREZOR PROTOCOL */
301  /* ======================================================================= */
302 
306  bool ping();
307 
311  void device_state_reset();
312 
313  // Protocol callbacks
314  void on_button_request(GenericMessage & resp, const messages::common::ButtonRequest * msg);
315  void on_button_pressed();
316  void on_pin_request(GenericMessage & resp, const messages::common::PinMatrixRequest * msg);
317  void on_passphrase_request(GenericMessage & resp, const messages::common::PassphraseRequest * msg);
318  void on_passphrase_state_request(GenericMessage & resp, const messages::common::PassphraseStateRequest * msg);
319 
320 #ifdef WITH_TREZOR_DEBUGGING
321  void set_debug(bool debug){
322  m_debug = debug;
323  }
324 
325  void set_debug_callback(std::shared_ptr<trezor_debug_callback> & debug_callback){
326  m_debug_callback = debug_callback;
327  }
328 
329  void wipe_device();
330  void init_device();
331  void load_device(const std::string & mnemonic, const std::string & pin="", bool passphrase_protection=false,
332  const std::string & label="test", const std::string & language="english",
333  bool skip_checksum=false, bool expand=false);
334 
335 #endif
336  };
337 
338 #endif
339 
340 }
341 }
342 #endif //ELECTRONEUM_DEVICE_TREZOR_BASE_H
#define CHECK_AND_ASSERT_THROW_MES(expr, message)
Definition: misc_log_ex.h:173
::std::string string
Definition: gtest-port.h:1097
const char * name
unsigned int uint32_t
Definition: stdint.h:126
unsigned __int64 uint64_t
Definition: stdint.h:136
Definition: device.cpp:38
void throw_failure_exception(const messages::common::Failure *failure)
Definition: transport.cpp:1217
uint64_t pack_version(uint32_t major, uint32_t minor, uint32_t patch)
Definition: transport.cpp:90
Definition: blake256.h:37
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
int bool
Definition: stdbool.h:36
connection< TProtocol > & operator=(const connection< TProtocol > &obj)