hw::trezor Namespace Reference

Namespaces
namespace	exc
namespace	protocol

Classes
class	DebugLink
class	MessageMapper
struct	trezor_usb_desc_t
class	Protocol
class	ProtocolV1
class	Transport
class	BridgeTransport
class	UdpTransport
class	GenericMessage

Typedefs
using	json = rapidjson::Document
using	json_val = rapidjson::Value
typedef std::vector< std::shared_ptr< Transport > >	t_transport_vect

Functions
void	register_all (std::map< std::string, std::unique_ptr< device > > &registry)
void	register_all ()
template<class t_message = google::protobuf::Message>
std::shared_ptr< t_message >	message_ptr_retype (std::shared_ptr< google::protobuf::Message > &in)
template<class t_message = google::protobuf::Message>
std::shared_ptr< t_message >	message_ptr_retype_static (std::shared_ptr< google::protobuf::Message > &in)
bool	t_serialize (const std::string &in, std::string &out)
bool	t_serialize (const json_val &in, std::string &out)
std::string	t_serialize (const json_val &in)
bool	t_deserialize (const std::string &in, std::string &out)
bool	t_deserialize (const std::string &in, json &out)
uint64_t	pack_version (uint32_t major, uint32_t minor, uint32_t patch)
void	enumerate (t_transport_vect &res)
void	sort_transports_by_env (t_transport_vect &res)
std::shared_ptr< Transport >	transport (const std::string &path)
void	throw_failure_exception (const messages::common::Failure *failure)
std::ostream &	operator<< (std::ostream &o, hw::trezor::Transport const &t)
std::ostream &	operator<< (std::ostream &o, std::shared_ptr< hw::trezor::Transport > const &t)
template<class t_req, class t_res, class t_transport>
bool	invoke_bridge_http (const boost::string_ref uri, const t_req &out_struct, t_res &result_struct, t_transport &transport, const boost::string_ref method="POST", std::chrono::milliseconds timeout=std::chrono::seconds(180))
template<class t_transport = Transport>
std::shared_ptr< t_transport >	transport_typed (const std::string &path)
template<class t_message = google::protobuf::Message>
std::shared_ptr< t_message >	exchange_message (Transport &transport, const google::protobuf::Message &req, boost::optional< messages::MessageType > resp_type=boost::none)

Variables
const char *	TYPE_PREFIX = "MessageType_"
const char *	PACKAGES []
const std::string	DEFAULT_BRIDGE = "127.0.0.1:21325"

Typedef Documentation

json

using hw::trezor::json = rapidjson::Document

Definition at line 59 of file transport.hpp.

json_val

using hw::trezor::json_val = rapidjson::Value

Definition at line 60 of file transport.hpp.

t_transport_vect

typedef std::vector<std::shared_ptr<Transport> > hw::trezor::t_transport_vect

Definition at line 135 of file transport.hpp.

Function Documentation

enumerate()

void hw::trezor::enumerate

(

t_transport_vect &

res

)

Enumerates all transports

Definition at line 1144 of file transport.cpp.

                                        {
    BridgeTransport bt;
    try{
      bt.enumerate(res);
    } catch (const std::exception & e){
      MERROR("BridgeTransport enumeration failed:" << e.what());
    }
 
#ifdef WITH_DEVICE_TREZOR_WEBUSB
    hw::trezor::WebUsbTransport btw;
    try{
      btw.enumerate(res);
    } catch (const std::exception & e){
      MERROR("WebUsbTransport enumeration failed:" << e.what());
    }
#endif
 
#ifdef WITH_DEVICE_TREZOR_UDP
    hw::trezor::UdpTransport btu;
    try{
      btu.enumerate(res);
    } catch (const std::exception & e){
      MERROR("UdpTransport enumeration failed:" << e.what());
    }
#endif
  }

Here is the call graph for this function:

exchange_message()

template<class t_message = google::protobuf::Message>

std::shared_ptr< t_message > hw::trezor::exchange_message	(	Transport &	transport,
		const google::protobuf::Message &	req,
		boost::optional< messages::MessageType >	resp_type = boost::none )

Simple wrapper for write-read message exchange with expected message response type.

Exceptions

UnexpectedMessageException

if the response message type is different than expected. Exception contains message type and the message itself.

Definition at line 373 of file transport.hpp.

  {
    // Require strictly protocol buffers response in the template.
    BOOST_STATIC_ASSERT(boost::is_base_of<google::protobuf::Message, t_message>::value);
 
    // Write the request
    transport.write(req);
 
    // Read the response
    std::shared_ptr<google::protobuf::Message> msg_resp;
    hw::trezor::messages::MessageType msg_resp_type;
    transport.read(msg_resp, &msg_resp_type);
 
    // Determine type of expected message response
    messages::MessageType required_type = resp_type ? resp_type.get() : MessageMapper::get_message_wire_number<t_message>();
 
    if (msg_resp_type == required_type) {
      return message_ptr_retype<t_message>(msg_resp);
    } else if (msg_resp_type == messages::MessageType_Failure){
      throw_failure_exception(dynamic_cast<messages::common::Failure*>(msg_resp.get()));
    } else {
      throw exc::UnexpectedMessageException(msg_resp_type, msg_resp);
    }
  }

Here is the call graph for this function:

invoke_bridge_http()

template<class t_req, class t_res, class t_transport>

bool hw::trezor::invoke_bridge_http	(	const boost::string_ref	uri,
		const t_req &	out_struct,
		t_res &	result_struct,
		t_transport &	transport,
		const boost::string_ref	method = "POST",
		std::chrono::milliseconds	timeout = std::chrono::seconds(180) )

Definition at line 77 of file transport.hpp.

  {
    std::string req_param;
    t_serialize(out_struct, req_param);
 
    http::fields_list additional_params;
    additional_params.push_back(std::make_pair("Origin","https://electroneum.trezor.io"));
    additional_params.push_back(std::make_pair("Content-Type","application/json; charset=utf-8"));
 
    const http::http_response_info* pri = nullptr;
    if(!transport.invoke(uri, method, req_param, timeout, &pri, std::move(additional_params)))
    {
      MERROR("Failed to invoke http request to  " << uri);
      return false;
    }
 
    if(!pri)
    {
      MERROR("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
      return false;
    }
 
    if(pri->m_response_code != 200)
    {
      MERROR("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code
             << " Response Body: " << pri->m_body);
      return false;
    }
 
    return t_deserialize(pri->m_body, result_struct);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

message_ptr_retype()

template<class t_message = google::protobuf::Message>

std::shared_ptr< t_message > hw::trezor::message_ptr_retype

(

std::shared_ptr< google::protobuf::Message > &

in

)

Definition at line 73 of file messages_map.hpp.

                                                                                        {
    BOOST_STATIC_ASSERT(boost::is_base_of<google::protobuf::Message, t_message>::value);
    if (!in){
      return nullptr;
    }
 
    return std::dynamic_pointer_cast<t_message>(in);
  }

Here is the caller graph for this function:

message_ptr_retype_static()

template<class t_message = google::protobuf::Message>

std::shared_ptr< t_message > hw::trezor::message_ptr_retype_static

(

std::shared_ptr< google::protobuf::Message > &

in

)

Definition at line 83 of file messages_map.hpp.

                                                                                               {
    BOOST_STATIC_ASSERT(boost::is_base_of<google::protobuf::Message, t_message>::value);
    if (!in){
      return nullptr;
    }
 
    return std::static_pointer_cast<t_message>(in);
  }

operator<<() [1/2]

std::ostream & hw::trezor::operator<<	(	std::ostream &	o,
		hw::trezor::Transport const &	t )

Definition at line 1251 of file transport.cpp.

                                                                   {
    return t.dump(o);
  }

Here is the call graph for this function:

operator<<() [2/2]

std::ostream & hw::trezor::operator<<	(	std::ostream &	o,
		std::shared_ptr< hw::trezor::Transport > const &	t )

Definition at line 1255 of file transport.cpp.

                                                                                  {
    if (!t){
      return o << "None";
    }
 
    return t->dump(o);
  }

pack_version()

uint64_t hw::trezor::pack_version	(	uint32_t	major,
		uint32_t	minor,
		uint32_t	patch )

Definition at line 90 of file transport.cpp.

  {
    // packing (major, minor, patch) to 64 B: 16 B | 24 B | 24 B
    const unsigned bits_1 = 16;
    const unsigned bits_2 = 24;
    const uint32_t mask_1 = (1 << bits_1) - 1;
    const uint32_t mask_2 = (1 << bits_2) - 1;
    CHECK_AND_ASSERT_THROW_MES(major <= mask_1 && minor <= mask_2 && patch <= mask_2, "Version numbers overflow packing scheme");
    return patch | (((uint64_t)minor) << bits_2) | (((uint64_t)major) << (bits_1 + bits_2));
  }

Here is the caller graph for this function:

register_all() [1/2]

void hw::trezor::register_all

(

)

Definition at line 735 of file device_trezor.cpp.

                        {
    }

register_all() [2/2]

void hw::trezor::register_all

(

std::map< std::string, std::unique_ptr< device > > &

registry

)

Definition at line 732 of file device_trezor.cpp.

                                                                          {
    }

sort_transports_by_env()

void hw::trezor::sort_transports_by_env

(

t_transport_vect &

res

)

Sorts found transports by TREZOR_PATH environment variable.

Definition at line 1171 of file transport.cpp.

                                                     {
    const char *env_trezor_path = getenv("TREZOR_PATH");
    if (!env_trezor_path){
      return;
    }
    
    // Sort transports by the longest matching prefix with TREZOR_PATH
    std::string trezor_path(env_trezor_path);
    std::vector<size_t> match_idx(res.size());
    std::vector<size_t> path_permutation(res.size());
 
    for(size_t i = 0; i < res.size(); ++i){
      auto cpath = res[i]->get_path();
      std::string * s1 = &trezor_path;
      std::string * s2 = &cpath;
      
      // first has to be shorter in std::mismatch(). Returns first non-matching iterators.
      if (s1->size() >= s2->size()){
        std::swap(s1, s2);
      }
 
      const auto mism = std::mismatch(s1->begin(), s1->end(), s2->begin());
      match_idx[i] = mism.first - s1->begin();
      path_permutation[i] = i;
    }
 
    std::sort(path_permutation.begin(), path_permutation.end(), [&](const size_t i0, const size_t i1) {
      return match_idx[i0] > match_idx[i1];
    });
 
    tools::apply_permutation(path_permutation, res);
  }

Here is the call graph for this function:

t_deserialize() [1/2]

bool hw::trezor::t_deserialize	(	const std::string &	in,
		json &	out )

Definition at line 79 of file transport.cpp.

                                                      {
    if (out.Parse(in.c_str()).HasParseError()) {
      throw exc::CommunicationException("JSON parse error");
    }
    return true;
  }

t_deserialize() [2/2]

bool hw::trezor::t_deserialize	(	const std::string &	in,
		std::string &	out )

Definition at line 74 of file transport.cpp.

                                                           {
    out = in;
    return true;
  }

Here is the caller graph for this function:

t_serialize() [1/3]

std::string hw::trezor::t_serialize

(

const json_val &

in

)

Definition at line 68 of file transport.cpp.

                                            {
    std::string ret;
    t_serialize(in, ret);
    return ret;
  }

Here is the call graph for this function:

t_serialize() [2/3]

bool hw::trezor::t_serialize	(	const json_val &	in,
		std::string &	out )

Definition at line 60 of file transport.cpp.

                                                        {
    rapidjson::StringBuffer sb;
    rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
    in.Accept(writer);
    out = sb.GetString();
    return true;
  }

t_serialize() [3/3]

bool hw::trezor::t_serialize	(	const std::string &	in,
		std::string &	out )

Definition at line 55 of file transport.cpp.

                                                         {
    out = in;
    return true;
  }

Here is the caller graph for this function:

throw_failure_exception()

void hw::trezor::throw_failure_exception

(

const messages::common::Failure *

failure

)

Throws corresponding failure exception.

Definition at line 1217 of file transport.cpp.

                                                                      {
    if (failure == nullptr){
      throw std::invalid_argument("Failure message cannot be null");
    }
 
    boost::optional<std::string> message = failure->has_message() ? boost::make_optional(failure->message()) : boost::none;
    boost::optional<uint32_t> code = failure->has_code() ? boost::make_optional(static_cast<uint32_t>(failure->code())) : boost::none;
    if (!code){
      throw exc::proto::FailureException(code, message);
    }
 
    auto ecode = failure->code();
    if (ecode == messages::common::Failure_FailureType_Failure_UnexpectedMessage){
      throw exc::proto::UnexpectedMessageException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_ActionCancelled){
      throw exc::proto::CancelledException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_PinExpected){
      throw exc::proto::PinExpectedException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_PinInvalid){
      throw exc::proto::InvalidPinException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_NotEnoughFunds){
      throw exc::proto::NotEnoughFundsException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_NotInitialized){
      throw exc::proto::NotInitializedException(code, message);
    } else if (ecode == messages::common::Failure_FailureType_Failure_FirmwareError){
      throw exc::proto::FirmwareErrorException(code, message);
    } else {
      throw exc::proto::FailureException(code, message);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

transport()

std::shared_ptr< Transport > hw::trezor::transport

(

const std::string &

path

)

Transforms path to the transport

Definition at line 1204 of file transport.cpp.

                                                            {
    if (boost::starts_with(path, BridgeTransport::PATH_PREFIX)){
      return std::make_shared<BridgeTransport>(path.substr(strlen(BridgeTransport::PATH_PREFIX)));
 
    } else if (boost::starts_with(path, UdpTransport::PATH_PREFIX)){
      return std::make_shared<UdpTransport>(path.substr(strlen(UdpTransport::PATH_PREFIX)));
 
    } else {
      throw std::invalid_argument("Unknown Trezor device path: " + path);
 
    }
  }

Here is the caller graph for this function:

transport_typed()

template<class t_transport = Transport>

std::shared_ptr< t_transport > hw::trezor::transport_typed

(

const std::string &

path

)

Transforms path to the particular transport

Definition at line 319 of file transport.hpp.

                                                                    {
    auto t = transport(path);
    if (!t){
      return nullptr;
    }
 
    return std::dynamic_pointer_cast<t_transport>(t);
  }

Here is the call graph for this function:

Variable Documentation

DEFAULT_BRIDGE

const std::string hw::trezor::DEFAULT_BRIDGE = "127.0.0.1:21325"

Definition at line 63 of file transport.hpp.

PACKAGES

const char* hw::trezor::PACKAGES[]

Initial value:

                     = {
    "hw.trezor.messages.",
    "hw.trezor.messages.common.",
    "hw.trezor.messages.management.",
 
 
 
    "hw.trezor.messages.electroneum."
}

Definition at line 48 of file messages_map.cpp.

                          {
      "hw.trezor.messages.",
      "hw.trezor.messages.common.",
      "hw.trezor.messages.management.",
#ifdef WITH_TREZOR_DEBUGGING
      "hw.trezor.messages.debug.",
#endif
      "hw.trezor.messages.electroneum."
  };

TYPE_PREFIX

const char* hw::trezor::TYPE_PREFIX = "MessageType_"

Definition at line 47 of file messages_map.cpp.