hw::trezor::protocol::ki Namespace Reference

Typedefs
using	ElectroneumTransferDetails = messages::electroneum::ElectroneumKeyImageSyncStepRequest_ElectroneumTransferDetails
using	ElectroneumSubAddressIndicesList = messages::electroneum::ElectroneumKeyImageExportInitRequest_ElectroneumSubAddressIndicesList
using	ElectroneumExportedKeyImage = messages::electroneum::ElectroneumKeyImageSyncStepAck_ElectroneumExportedKeyImage
using	exported_key_image = hw::device_cold::exported_key_image

Functions
bool	key_image_data (wallet_shim *wallet, const std::vector< tools::wallet2::transfer_details > &transfers, std::vector< ElectroneumTransferDetails > &res)
std::string	compute_hash (const ElectroneumTransferDetails &rr)
void	generate_commitment (std::vector< ElectroneumTransferDetails > &mtds, const std::vector< tools::wallet2::transfer_details > &transfers, std::shared_ptr< messages::Electroneum::ElectroneumKeyImageExportInitRequest > &req)
void	live_refresh_ack (const ::crypto::secret_key &view_key_priv, const ::crypto::public_key &out_key, const std::shared_ptr< messages::Electroneum::ElectroneumLiveRefreshStepAck > &ack, ::cryptonote::keypair &in_ephemeral, ::crypto::key_image &ki)
void	generate_commitment (std::vector< ElectroneumTransferDetails > &mtds, const std::vector< tools::wallet2::transfer_details > &transfers, std::shared_ptr< messages::electroneum::ElectroneumKeyImageExportInitRequest > &req)
void	live_refresh_ack (const ::crypto::secret_key &view_key_priv, const ::crypto::public_key &out_key, const std::shared_ptr< messages::electroneum::ElectroneumLiveRefreshStepAck > &ack, ::cryptonote::keypair &in_ephemeral, ::crypto::key_image &ki)

Typedef Documentation

ElectroneumExportedKeyImage

using hw::trezor::protocol::ki::ElectroneumExportedKeyImage = messages::electroneum::ElectroneumKeyImageSyncStepAck_ElectroneumExportedKeyImage

Definition at line 113 of file protocol.hpp.

ElectroneumSubAddressIndicesList

using hw::trezor::protocol::ki::ElectroneumSubAddressIndicesList = messages::electroneum::ElectroneumKeyImageExportInitRequest_ElectroneumSubAddressIndicesList

Definition at line 112 of file protocol.hpp.

ElectroneumTransferDetails

using hw::trezor::protocol::ki::ElectroneumTransferDetails = messages::electroneum::ElectroneumKeyImageSyncStepRequest_ElectroneumTransferDetails

Definition at line 111 of file protocol.hpp.

exported_key_image

using hw::trezor::protocol::ki::exported_key_image = hw::device_cold::exported_key_image

Definition at line 114 of file protocol.hpp.

Function Documentation

compute_hash()

std::string hw::trezor::protocol::ki::compute_hash

(

const ElectroneumTransferDetails &

rr

)

Computes a hash over ElectroneumTransferDetails. Commitment used in the KI sync.

Definition at line 167 of file protocol.cpp.

                                                               {
    KECCAK_CTX kck;
    uint8_t md[32];
 
    CHECK_AND_ASSERT_THROW_MES(rr.out_key().size() == 32, "Invalid out_key size");
    CHECK_AND_ASSERT_THROW_MES(rr.tx_pub_key().size() == 32, "Invalid tx_pub_key size");
 
    keccak_init(&kck);
    keccak_update(&kck, reinterpret_cast<const uint8_t *>(rr.out_key().data()), 32);
    keccak_update(&kck, reinterpret_cast<const uint8_t *>(rr.tx_pub_key().data()), 32);
    for (const auto &aux : rr.additional_tx_pub_keys()){
      CHECK_AND_ASSERT_THROW_MES(aux.size() == 32, "Invalid aux size");
      keccak_update(&kck, reinterpret_cast<const uint8_t *>(aux.data()), 32);
    }
 
    auto index_serialized = tools::get_varint_data(rr.internal_output_index());
    keccak_update(&kck, reinterpret_cast<const uint8_t *>(index_serialized.data()), index_serialized.size());
    keccak_finish(&kck, md);
    return std::string(reinterpret_cast<const char*>(md), sizeof(md));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

generate_commitment() [1/2]

void hw::trezor::protocol::ki::generate_commitment	(	std::vector< ElectroneumTransferDetails > &	mtds,
		const std::vector< tools::wallet2::transfer_details > &	transfers,
		std::shared_ptr< messages::Electroneum::ElectroneumKeyImageExportInitRequest > &	req )

Definition at line 188 of file protocol.cpp.

  {
    req = std::make_shared<messages::Electroneum::ElectroneumKeyImageExportInitRequest>();
 
    KECCAK_CTX kck;
    uint8_t final_hash[32];
    keccak_init(&kck);
 
    for(auto &cur : mtds){
      auto hash = compute_hash(cur);
      keccak_update(&kck, reinterpret_cast<const uint8_t *>(hash.data()), hash.size());
    }
    keccak_finish(&kck, final_hash);
 
    req = std::make_shared<messages::Electroneum::ElectroneumKeyImageExportInitRequest>();
    req->set_hash(std::string(reinterpret_cast<const char*>(final_hash), 32));
    req->set_num(transfers.size());
 
    std::unordered_map<uint32_t, std::set<uint32_t>> sub_indices;
    for (auto &cur : transfers){
      auto search = sub_indices.emplace(cur.m_subaddr_index.major, std::set<uint32_t>());
      auto & st = search.first->second;
      st.insert(cur.m_subaddr_index.minor);
    }
 
    for (auto& x: sub_indices){
      auto subs = req->add_subs();
      subs->set_account(x.first);
      for(auto minor : x.second){
        subs->add_minor_indices(minor);
      }
    }
  }

Here is the call graph for this function:

generate_commitment() [2/2]

void hw::trezor::protocol::ki::generate_commitment	(	std::vector< ElectroneumTransferDetails > &	mtds,
		const std::vector< tools::wallet2::transfer_details > &	transfers,
		std::shared_ptr< messages::electroneum::ElectroneumKeyImageExportInitRequest > &	req )

Generates KI sync request with commitments computed.

key_image_data()

bool hw::trezor::protocol::ki::key_image_data	(	wallet_shim *	wallet,
		const std::vector< tools::wallet2::transfer_details > &	transfers,
		std::vector< ElectroneumTransferDetails > &	res )

Converts transfer details to the ElectroneumTransferDetails required for KI sync

Definition at line 145 of file protocol.cpp.

  {
    for(auto & td : transfers){
      ::crypto::public_key tx_pub_key = wallet->get_tx_pub_key_from_received_outs(td);
      const std::vector<::crypto::public_key> additional_tx_pub_keys = cryptonote::get_additional_tx_pub_keys_from_extra(td.m_tx);
 
      res.emplace_back();
      auto & cres = res.back();
 
      cres.set_out_key(key_to_string(boost::get<cryptonote::txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key));
      cres.set_tx_pub_key(key_to_string(tx_pub_key));
      cres.set_internal_output_index(td.m_internal_output_index);
      for(auto & aux : additional_tx_pub_keys){
        cres.add_additional_tx_pub_keys(key_to_string(aux));
      }
    }
 
    return true;
  }

Here is the call graph for this function:

live_refresh_ack() [1/2]

void hw::trezor::protocol::ki::live_refresh_ack	(	const ::crypto::secret_key &	view_key_priv,
		const ::crypto::public_key &	out_key,
		const std::shared_ptr< messages::Electroneum::ElectroneumLiveRefreshStepAck > &	ack,
		::cryptonote::keypair &	in_ephemeral,
		::crypto::key_image &	ki )

Definition at line 224 of file protocol.cpp.

  {
    std::string str_out_key(out_key.data, sizeof(out_key.data));
    auto enc_key = protocol::tx::compute_enc_key(view_key_priv, str_out_key, ack->salt());
 
    const size_t len_ciphertext = ack->key_image().size();  // IV || keys
    CHECK_AND_ASSERT_THROW_MES(len_ciphertext > crypto::chacha::IV_SIZE + crypto::chacha::TAG_SIZE, "Invalid size");
 
    size_t ki_len = len_ciphertext - crypto::chacha::IV_SIZE - crypto::chacha::TAG_SIZE;
    std::unique_ptr<uint8_t[]> plaintext(new uint8_t[ki_len]);
    uint8_t * buff = plaintext.get();
 
    protocol::crypto::chacha::decrypt(
        ack->key_image().data() + crypto::chacha::IV_SIZE,
        len_ciphertext - crypto::chacha::IV_SIZE,
        reinterpret_cast<const uint8_t *>(enc_key.data),
        reinterpret_cast<const uint8_t *>(ack->key_image().data()),
        reinterpret_cast<char *>(buff), &ki_len);
 
    CHECK_AND_ASSERT_THROW_MES(ki_len == 3*32, "Invalid size");
    ::crypto::signature sig{};
    memcpy(ki.data, buff, 32);
    memcpy(sig.c.data, buff + 32, 32);
    memcpy(sig.r.data, buff + 64, 32);
    in_ephemeral.pub = out_key;
    in_ephemeral.sec = ::crypto::null_skey;
 
    // Verification
    std::vector<const ::crypto::public_key*> pkeys;
    pkeys.push_back(&out_key);
 
    CHECK_AND_ASSERT_THROW_MES(rct::scalarmultKey(rct::ki2rct(ki), rct::curveOrder()) == rct::identity(),
                               "Key image out of validity domain: key image " << epee::string_tools::pod_to_hex(ki));
 
    CHECK_AND_ASSERT_THROW_MES(::crypto::check_ring_signature((const ::crypto::hash&)ki, ki, pkeys, &sig),
                               "Signature failed for key image " << epee::string_tools::pod_to_hex(ki)
                                                                 << ", signature " + epee::string_tools::pod_to_hex(sig)
                                                                 << ", pubkey " + epee::string_tools::pod_to_hex(*pkeys[0]));
  }

Here is the call graph for this function:

live_refresh_ack() [2/2]

void hw::trezor::protocol::ki::live_refresh_ack	(	const ::crypto::secret_key &	view_key_priv,
		const ::crypto::public_key &	out_key,
		const std::shared_ptr< messages::electroneum::ElectroneumLiveRefreshStepAck > &	ack,
		::cryptonote::keypair &	in_ephemeral,
		::crypto::key_image &	ki )

Processes Live refresh step response, parses KI, checks the signature