hw::core::device_default Class Reference

#include <device_default.hpp>

Inheritance diagram for hw::core::device_default:

Collaboration diagram for hw::core::device_default:

Public Member Functions
	device_default ()
	~device_default ()
	device_default (const device_default &device)=delete
device_default &	operator= (const device_default &device)=delete
	operator bool () const override
bool	set_name (const std::string &name) override
const std::string	get_name () const override
bool	init (void) override
bool	release () override
bool	connect (void) override
bool	disconnect () override
bool	set_mode (device_mode mode) override
device_type	get_type () const override
void	lock (void) override
void	unlock (void) override
bool	try_lock (void) override
bool	get_public_address (cryptonote::account_public_address &pubkey) override
bool	get_secret_keys (crypto::secret_key &viewkey, crypto::secret_key &spendkey) override
bool	generate_chacha_key (const cryptonote::account_keys &keys, crypto::chacha_key &key, uint64_t kdf_rounds) override
bool	derive_subaddress_public_key (const crypto::public_key &pub, const crypto::key_derivation &derivation, const std::size_t output_index, crypto::public_key &derived_pub) override
crypto::public_key	get_subaddress_spend_public_key (const cryptonote::account_keys &keys, const cryptonote::subaddress_index &index) override
std::vector< crypto::public_key >	get_subaddress_spend_public_keys (const cryptonote::account_keys &keys, uint32_t account, uint32_t begin, uint32_t end) override
cryptonote::account_public_address	get_subaddress (const cryptonote::account_keys &keys, const cryptonote::subaddress_index &index) override
crypto::secret_key	get_subaddress_secret_key (const crypto::secret_key &sec, const cryptonote::subaddress_index &index) override
crypto::secret_key	get_subaddress_private_spendkey (const cryptonote::account_keys &keys, const cryptonote::subaddress_index &subaddr_index) override
crypto::secret_key	get_subaddress_private_viewkey (const crypto::secret_key &main_wallet_sec_view, crypto::secret_key &subaddress_sec_spend) override
bool	verify_keys (const crypto::secret_key &secret_key, const crypto::public_key &public_key) override
bool	scalarmultKey (rct::key &aP, const rct::key &P, const rct::key &a) override
bool	scalarmultBase (rct::key &aG, const rct::key &a) override
bool	sc_secret_add (crypto::secret_key &r, const crypto::secret_key &a, const crypto::secret_key &b) override
crypto::secret_key	generate_keys (crypto::public_key &pub, crypto::secret_key &sec, const crypto::secret_key &recovery_key=crypto::secret_key(), bool recover=false) override
bool	generate_key_derivation (const crypto::public_key &pub, const crypto::secret_key &sec, crypto::key_derivation &derivation) override
bool	conceal_derivation (crypto::key_derivation &derivation, const crypto::public_key &tx_pub_key, const std::vector< crypto::public_key > &additional_tx_pub_keys, const crypto::key_derivation &main_derivation, const std::vector< crypto::key_derivation > &additional_derivations) override
bool	derivation_to_scalar (const crypto::key_derivation &derivation, const size_t output_index, crypto::ec_scalar &res) override
bool	derive_secret_key (const crypto::key_derivation &derivation, const std::size_t output_index, const crypto::secret_key &sec, crypto::secret_key &derived_sec) override
bool	derive_public_key (const crypto::key_derivation &derivation, const std::size_t output_index, const crypto::public_key &pub, crypto::public_key &derived_pub) override
bool	secret_key_to_public_key (const crypto::secret_key &sec, crypto::public_key &pub) override
bool	generate_key_image (const crypto::public_key &pub, const crypto::secret_key &sec, crypto::key_image &image) override
void	generate_tx_proof (const crypto::hash &prefix_hash, const crypto::public_key &R, const crypto::public_key &A, const boost::optional< crypto::public_key > &B, const crypto::public_key &D, const crypto::secret_key &r, crypto::signature &sig) override
bool	open_tx (crypto::secret_key &tx_key) override
bool	encrypt_payment_id (crypto::hash8 &payment_id, const crypto::public_key &public_key, const crypto::secret_key &secret_key) override
rct::key	genCommitmentMask (const rct::key &amount_key) override
bool	ecdhEncode (rct::ecdhTuple &unmasked, const rct::key &sharedSec, bool short_amount) override
bool	ecdhDecode (rct::ecdhTuple &masked, const rct::key &sharedSec, bool short_amount) override
bool	generate_output_ephemeral_keys (const size_t tx_version, const cryptonote::account_keys &sender_account_keys, const crypto::public_key &txkey_pub, const crypto::secret_key &tx_key, const cryptonote::tx_destination_entry &dst_entr, const boost::optional< cryptonote::account_public_address > &change_addr, const size_t output_index, const bool &need_additional_txkeys, const std::vector< crypto::secret_key > &additional_tx_keys, std::vector< crypto::public_key > &additional_tx_public_keys, std::vector< rct::key > &amount_keys, crypto::public_key &out_eph_public_key) override
bool	mlsag_prehash (const std::string &blob, size_t inputs_size, size_t outputs_size, const rct::keyV &hashes, const rct::ctkeyV &outPk, rct::key &prehash) override
bool	mlsag_prepare (const rct::key &H, const rct::key &xx, rct::key &a, rct::key &aG, rct::key &aHP, rct::key &rvII) override
bool	mlsag_prepare (rct::key &a, rct::key &aG) override
bool	mlsag_hash (const rct::keyV &long_message, rct::key &c) override
bool	mlsag_sign (const rct::key &c, const rct::keyV &xx, const rct::keyV &alpha, const size_t rows, const size_t dsRows, rct::keyV &ss) override
bool	close_tx (void) override
bool	get_transaction_prefix_hash (const cryptonote::transaction_prefix &tx, crypto::hash &tx_prefix_hash) override
bool	generate_ring_signature (const crypto::hash &prefix_hash, const crypto::key_image &image, const std::vector< const crypto::public_key * > &pubs, const crypto::secret_key &sec, std::size_t sec_index, crypto::signature *sig) override
bool	generate_input_signature (const crypto::hash &prefix_hash, const uint32_t input_index, const crypto::secret_key sec_view, const crypto::secret_key sec_spend, crypto::signature &signature) override
bool	hash_to_scalar (boost::shared_ptr< crypto::rs_comm > buf, size_t length, crypto::ec_scalar &res) override
Public Member Functions inherited from hw::device
	device ()
	device (const device &hwdev)
virtual	~device ()
virtual device_mode	get_mode () const
virtual device_protocol_t	device_protocol () const
virtual void	set_callback (i_device_callback *callback)
virtual void	set_derivation_path (const std::string &derivation_path)
virtual void	set_pin (const epee::wipeable_string &pin)
virtual void	set_passphrase (const epee::wipeable_string &passphrase)
rct::key	scalarmultKey (const rct::key &P, const rct::key &a)
rct::key	scalarmultBase (const rct::key &a)
bool	decrypt_payment_id (crypto::hash8 &payment_id, const crypto::public_key &public_key, const crypto::secret_key &secret_key)
virtual bool	has_ki_cold_sync (void) const
virtual bool	has_tx_cold_sign (void) const
virtual bool	has_ki_live_refresh (void) const
virtual bool	compute_key_image (const cryptonote::account_keys &ack, const crypto::public_key &out_key, const crypto::key_derivation &recv_derivation, size_t real_output_index, const cryptonote::subaddress_index &received_index, cryptonote::keypair &in_ephemeral, crypto::key_image &ki)
virtual void	computing_key_images (bool started)
virtual void	set_network_type (cryptonote::network_type network_type)

Additional Inherited Members
Public Types inherited from hw::device
enum	device_mode { NONE , TRANSACTION_CREATE_REAL , TRANSACTION_CREATE_FAKE , TRANSACTION_PARSE }
enum	device_type { SOFTWARE = 0 , LEDGER = 1 , TREZOR = 2 }
enum	device_protocol_t { PROTOCOL_DEFAULT , PROTOCOL_PROXY , PROTOCOL_COLD }
Protected Attributes inherited from hw::device
std::string	name
device_mode	mode

Detailed Description

Definition at line 40 of file device_default.hpp.

Constructor & Destructor Documentation

device_default() [1/2]

hw::core::device_default::device_default

(

)

Definition at line 47 of file device_default.cpp.

{ }

Here is the caller graph for this function:

~device_default()

hw::core::device_default::~device_default

(

)

Definition at line 49 of file device_default.cpp.

{ }

device_default() [2/2]

hw::core::device_default::device_default ( const device_default & device )

delete

Here is the call graph for this function:

Member Function Documentation

close_tx()

bool hw::core::device_default::close_tx ( void )

overridevirtual

Implements hw::device.

Definition at line 422 of file device_default.cpp.

                                      {
            return true;
        }

Here is the caller graph for this function:

conceal_derivation()

bool hw::core::device_default::conceal_derivation ( crypto::key_derivation & derivation, const crypto::public_key & tx_pub_key, const std::vector< crypto::public_key > & additional_tx_pub_keys, const crypto::key_derivation & main_derivation, const std::vector< crypto::key_derivation > & additional_derivations )

overridevirtual

Implements hw::device.

Definition at line 287 of file device_default.cpp.

                                                                                                                                                                                                                                                                                          {
            return true;
        }

connect()

bool hw::core::device_default::connect ( void )

overridevirtual

Implements hw::device.

Definition at line 79 of file device_default.cpp.

                                         {
            return true;
        }

derivation_to_scalar()

bool hw::core::device_default::derivation_to_scalar ( const crypto::key_derivation & derivation, const size_t output_index, crypto::ec_scalar & res )

overridevirtual

Implements hw::device.

Definition at line 264 of file device_default.cpp.

                                                                                                                                        {
            crypto::derivation_to_scalar(derivation,output_index, res);
            return true;
        }

Here is the caller graph for this function:

derive_public_key()

bool hw::core::device_default::derive_public_key ( const crypto::key_derivation & derivation, const std::size_t output_index, const crypto::public_key & pub, crypto::public_key & derived_pub )

overridevirtual

Implements hw::device.

Definition at line 274 of file device_default.cpp.

                                                                                                                                                                               {
            return crypto::derive_public_key(derivation, output_index, base, derived_key);
        }

Here is the caller graph for this function:

derive_secret_key()

bool hw::core::device_default::derive_secret_key ( const crypto::key_derivation & derivation, const std::size_t output_index, const crypto::secret_key & sec, crypto::secret_key & derived_sec )

overridevirtual

Implements hw::device.

Definition at line 269 of file device_default.cpp.

                                                                                                                                                                               {
            crypto::derive_secret_key(derivation, output_index, base, derived_key);
            return true;
        }

Here is the caller graph for this function:

derive_subaddress_public_key()

bool hw::core::device_default::derive_subaddress_public_key ( const crypto::public_key & pub, const crypto::key_derivation & derivation, const std::size_t output_index, crypto::public_key & derived_pub )

overridevirtual

Implements hw::device.

Definition at line 124 of file device_default.cpp.

                                                                                                                                                                                              {
            return crypto::derive_subaddress_public_key(out_key, derivation, output_index,derived_key);
        }

Here is the call graph for this function:

disconnect()

bool hw::core::device_default::disconnect ( void )

overridevirtual

Implements hw::device.

Definition at line 82 of file device_default.cpp.

                                        {
            return true;
        }

ecdhDecode()

bool hw::core::device_default::ecdhDecode ( rct::ecdhTuple & masked, const rct::key & sharedSec, bool short_amount )

overridevirtual

Implements hw::device.

Definition at line 384 of file device_default.cpp.

                                                                                                           {
            rct::ecdhDecode(masked, sharedSec, short_amount);
            return true;
        }

Here is the caller graph for this function:

ecdhEncode()

bool hw::core::device_default::ecdhEncode ( rct::ecdhTuple & unmasked, const rct::key & sharedSec, bool short_amount )

overridevirtual

Implements hw::device.

Definition at line 379 of file device_default.cpp.

                                                                                                             {
            rct::ecdhEncode(unmasked, sharedSec, short_amount);
            return true;
        }

Here is the caller graph for this function:

encrypt_payment_id()

bool hw::core::device_default::encrypt_payment_id ( crypto::hash8 & payment_id, const crypto::public_key & public_key, const crypto::secret_key & secret_key )

overridevirtual

Implements hw::device.

Definition at line 357 of file device_default.cpp.

                                                                                                                                                {
            crypto::key_derivation derivation;
            crypto::hash hash;
            char data[33]; /* A hash, and an extra byte */
 
            if (!generate_key_derivation(public_key, secret_key, derivation))
                return false;
 
            memcpy(data, &derivation, 32);
            data[32] = ENCRYPTED_PAYMENT_ID_TAIL;
            cn_fast_hash(data, 33, hash);
 
            for (size_t b = 0; b < 8; ++b)
                payment_id.data[b] ^= hash.data[b];
 
            return true;
        }

genCommitmentMask()

rct::key hw::core::device_default::genCommitmentMask ( const rct::key & amount_key )

overridevirtual

Implements hw::device.

Definition at line 375 of file device_default.cpp.

                                                                         {
            return rct::genCommitmentMask(amount_key);
        }

generate_chacha_key()

bool hw::core::device_default::generate_chacha_key ( const cryptonote::account_keys & keys, crypto::chacha_key & key, uint64_t kdf_rounds )

overridevirtual

Implements hw::device.

Definition at line 104 of file device_default.cpp.

                                                                                                                                {
            const crypto::secret_key &view_key = keys.m_view_secret_key;
            const crypto::secret_key &spend_key = keys.m_spend_secret_key;
            epee::mlocked<tools::scrubbed_arr<char, sizeof(view_key) + sizeof(spend_key) + 1>> data;
            memcpy(data.data(), &view_key, sizeof(view_key));
            memcpy(data.data() + sizeof(view_key), &spend_key, sizeof(spend_key));
            data[sizeof(data) - 1] = CHACHA8_KEY_TAIL;
            crypto::generate_chacha_key(data.data(), sizeof(data), key, kdf_rounds);
            return true;
        }

Here is the call graph for this function:

generate_input_signature()

bool hw::core::device_default::generate_input_signature ( const crypto::hash & prefix_hash, const uint32_t input_index, const crypto::secret_key sec_view, const crypto::secret_key sec_spend, crypto::signature & signature )

overridevirtual

Implements hw::device.

Definition at line 450 of file device_default.cpp.

                                                                                                                                                                                                             {
            crypto::generate_input_signature(prefix_hash, input_index, sec_view, sec_spend, signature);
            return true;
        }

generate_key_derivation()

bool hw::core::device_default::generate_key_derivation ( const crypto::public_key & pub, const crypto::secret_key & sec, crypto::key_derivation & derivation )

overridevirtual

Implements hw::device.

Definition at line 260 of file device_default.cpp.

                                                                                                                                                 {
            return crypto::generate_key_derivation(key1, key2, derivation);
        }

Here is the caller graph for this function:

generate_key_image()

bool hw::core::device_default::generate_key_image ( const crypto::public_key & pub, const crypto::secret_key & sec, crypto::key_image & image )

overridevirtual

Implements hw::device.

Definition at line 282 of file device_default.cpp.

                                                                                                                               {
            crypto::generate_key_image(pub, sec,image);
            return true;
        }

Here is the caller graph for this function:

generate_keys()

crypto::secret_key hw::core::device_default::generate_keys ( crypto::public_key & pub, crypto::secret_key & sec, const crypto::secret_key & recovery_key = crypto::secret_key(), bool recover = false )

overridevirtual

Implements hw::device.

Definition at line 256 of file device_default.cpp.

                                                                                                                                                        {
            return crypto::generate_keys(pub, sec, recovery_key, recover);
        }

generate_output_ephemeral_keys()

bool hw::core::device_default::generate_output_ephemeral_keys ( const size_t tx_version, const cryptonote::account_keys & sender_account_keys, const crypto::public_key & txkey_pub, const crypto::secret_key & tx_key, const cryptonote::tx_destination_entry & dst_entr, const boost::optional< cryptonote::account_public_address > & change_addr, const size_t output_index, const bool & need_additional_txkeys, const std::vector< crypto::secret_key > & additional_tx_keys, std::vector< crypto::public_key > & additional_tx_public_keys, std::vector< rct::key > & amount_keys, crypto::public_key & out_eph_public_key )

overridevirtual

Implements hw::device.

Definition at line 306 of file device_default.cpp.

                                                                                                                                   {
 
            crypto::key_derivation derivation;
 
            // make additional tx pubkey if necessary
            cryptonote::keypair additional_txkey;
            if (need_additional_txkeys)
            {
                additional_txkey.sec = additional_tx_keys[output_index];
                if (dst_entr.is_subaddress)
                    additional_txkey.pub = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(dst_entr.addr.m_spend_public_key), rct::sk2rct(additional_txkey.sec)));
                else
                    additional_txkey.pub = rct::rct2pk(rct::scalarmultBase(rct::sk2rct(additional_txkey.sec)));
            }
 
            bool r;
            if (change_addr && dst_entr.addr == *change_addr)
            {
            // sending change to yourself; derivation = a*R
                r = generate_key_derivation(txkey_pub, sender_account_keys.m_view_secret_key, derivation);
                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation(" << txkey_pub << ", " << sender_account_keys.m_view_secret_key << ")");
            }
            else
            {
            // sending to the recipient; derivation = r*A (or s*C in the subaddress scheme)
                r = generate_key_derivation(dst_entr.addr.m_view_public_key, dst_entr.is_subaddress && need_additional_txkeys ? additional_txkey.sec : tx_key, derivation);
                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation(" << dst_entr.addr.m_view_public_key << ", " << (dst_entr.is_subaddress && need_additional_txkeys ? additional_txkey.sec : tx_key) << ")");
            }
 
            if (need_additional_txkeys)
            {
                additional_tx_public_keys.push_back(additional_txkey.pub);
            }
 
            if (tx_version > 1)
            {
                crypto::secret_key scalar1;
                derivation_to_scalar(derivation, output_index, scalar1);
                amount_keys.push_back(rct::sk2rct(scalar1));
            }
            r = derive_public_key(derivation, output_index, dst_entr.addr.m_spend_public_key, out_eph_public_key);
            CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to derive_public_key(" << derivation << ", " << output_index << ", "<< dst_entr.addr.m_spend_public_key << ")");
 
            return r;
        }

generate_ring_signature()

bool hw::core::device_default::generate_ring_signature ( const crypto::hash & prefix_hash, const crypto::key_image & image, const std::vector< const crypto::public_key * > & pubs, const crypto::secret_key & sec, std::size_t sec_index, crypto::signature * sig )

overridevirtual

Implements hw::device.

Definition at line 442 of file device_default.cpp.

                                                                          {
            crypto::generate_ring_signature(prefix_hash, image, pubs.data(), pubs.size(), sec, sec_index, sig);
            return true;
        }

generate_tx_proof()

void hw::core::device_default::generate_tx_proof ( const crypto::hash & prefix_hash, const crypto::public_key & R, const crypto::public_key & A, const boost::optional< crypto::public_key > & B, const crypto::public_key & D, const crypto::secret_key & r, crypto::signature & sig )

overridevirtual

Implements hw::device.

Definition at line 294 of file device_default.cpp.

                                                                     {
            crypto::generate_tx_proof(prefix_hash, R, A, B, D, r, sig);
        }

get_name()

const std::string hw::core::device_default::get_name ( ) const

overridevirtual

Implements hw::device.

Definition at line 68 of file device_default.cpp.

                                                        {
            return this->name;
        }

Here is the caller graph for this function:

get_public_address()

bool hw::core::device_default::get_public_address ( cryptonote::account_public_address & pubkey )

overridevirtual

Implements hw::device.

Definition at line 114 of file device_default.cpp.

                                                                                         {
             dfns();
        }

get_secret_keys()

bool hw::core::device_default::get_secret_keys ( crypto::secret_key & viewkey, crypto::secret_key & spendkey )

overridevirtual

Implements hw::device.

Definition at line 117 of file device_default.cpp.

                                                                                                     {
             dfns();
        }

get_subaddress()

cryptonote::account_public_address hw::core::device_default::get_subaddress ( const cryptonote::account_keys & keys, const cryptonote::subaddress_index & index )

overridevirtual

Implements hw::device.

Definition at line 182 of file device_default.cpp.

                                                                                                                                                   {
            if (index.is_zero())
              return keys.m_account_address;
 
            crypto::public_key D = get_subaddress_spend_public_key(keys, index);
 
            // C = a*D
            crypto::public_key C = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(D), rct::sk2rct(keys.m_view_secret_key)));
 
            // result: (C, D)
            cryptonote::account_public_address address;
            address.m_view_public_key  = C;
            address.m_spend_public_key = D;
            return address;
        }

get_subaddress_private_spendkey()

crypto::secret_key hw::core::device_default::get_subaddress_private_spendkey ( const cryptonote::account_keys & keys, const cryptonote::subaddress_index & subaddr_index )

overridevirtual

Implements hw::device.

Definition at line 215 of file device_default.cpp.

                                                                                                                                                           {
            crypto::secret_key subaddr_secret_key = get_subaddress_secret_key(keys.m_view_secret_key, subaddr_index);
            crypto::secret_key subaddr_private_spendkey;
            sc_secret_add(subaddr_private_spendkey, subaddr_secret_key, keys.m_spend_secret_key);
            return subaddr_private_spendkey;
        }

get_subaddress_private_viewkey()

crypto::secret_key hw::core::device_default::get_subaddress_private_viewkey ( const crypto::secret_key & main_wallet_sec_view, crypto::secret_key & subaddress_sec_spend )

overridevirtual

Implements hw::device.

Definition at line 225 of file device_default.cpp.

                                                                                                                                                           {
            crypto::secret_key subaddr_private_viewkey;
            sc_mul(&subaddr_private_viewkey, &main_wallet_sec_view, &subaddress_sec_spend);
            return subaddr_private_viewkey;
        }

get_subaddress_secret_key()

crypto::secret_key hw::core::device_default::get_subaddress_secret_key ( const crypto::secret_key & sec, const cryptonote::subaddress_index & index )

overridevirtual

Implements hw::device.

Definition at line 198 of file device_default.cpp.

                                                                                                                                     {
            const char prefix[] = "SubAddr";
            char data[sizeof(prefix) + sizeof(crypto::secret_key) + 2 * sizeof(uint32_t)];
            memcpy(data, prefix, sizeof(prefix));
            memcpy(data + sizeof(prefix), &a, sizeof(crypto::secret_key));
            uint32_t idx = SWAP32LE(index.major);
            memcpy(data + sizeof(prefix) + sizeof(crypto::secret_key), &idx, sizeof(uint32_t));
            idx = SWAP32LE(index.minor);
            memcpy(data + sizeof(prefix) + sizeof(crypto::secret_key) + sizeof(uint32_t), &idx, sizeof(uint32_t));
            crypto::secret_key m;
            crypto::hash_to_scalar(data, sizeof(data), m);
            return m;
        }

Here is the caller graph for this function:

get_subaddress_spend_public_key()

crypto::public_key hw::core::device_default::get_subaddress_spend_public_key ( const cryptonote::account_keys & keys, const cryptonote::subaddress_index & index )

overridevirtual

Implements hw::device.

Definition at line 128 of file device_default.cpp.

                                                                                                                                                    {
            if (index.is_zero())
              return keys.m_account_address.m_spend_public_key;
 
            // m = Hs(a || index_major || index_minor)
            crypto::secret_key m = get_subaddress_secret_key(keys.m_view_secret_key, index);
 
            // M = m*G
            crypto::public_key M;
            crypto::secret_key_to_public_key(m, M);
 
            // D = B + M
            crypto::public_key D = rct::rct2pk(rct::addKeys(rct::pk2rct(keys.m_account_address.m_spend_public_key), rct::pk2rct(M)));
            return D;
        }

Here is the call graph for this function:

get_subaddress_spend_public_keys()

std::vector< crypto::public_key > hw::core::device_default::get_subaddress_spend_public_keys ( const cryptonote::account_keys & keys, uint32_t account, uint32_t begin, uint32_t end )

overridevirtual

Implements hw::device.

Definition at line 144 of file device_default.cpp.

                                                                                                                                                                        {
            CHECK_AND_ASSERT_THROW_MES(begin <= end, "begin > end");
 
            std::vector<crypto::public_key> pkeys;
            pkeys.reserve(end - begin);
            cryptonote::subaddress_index index = {account, begin};
 
            ge_p3 p3;
            ge_cached cached;
            CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&p3, (const unsigned char*)keys.m_account_address.m_spend_public_key.data) == 0,
                "ge_frombytes_vartime failed to convert spend public key");
            ge_p3_to_cached(&cached, &p3);
 
            for (uint32_t idx = begin; idx < end; ++idx)
            {
                index.minor = idx;
                if (index.is_zero())
                {
                    pkeys.push_back(keys.m_account_address.m_spend_public_key);
                    continue;
                }
                crypto::secret_key m = get_subaddress_secret_key(keys.m_view_secret_key, index);
 
                // M = m*G
                ge_scalarmult_base(&p3, (const unsigned char*)m.data);
 
                // D = B + M
                crypto::public_key D;
                ge_p1p1 p1p1;
                ge_add(&p1p1, &p3, &cached);
                ge_p1p1_to_p3(&p3, &p1p1);
                ge_p3_tobytes((unsigned char*)D.data, &p3);
 
                pkeys.push_back(D);
            }
            return pkeys;
        }

Here is the call graph for this function:

get_transaction_prefix_hash()

bool hw::core::device_default::get_transaction_prefix_hash ( const cryptonote::transaction_prefix & tx, crypto::hash & tx_prefix_hash )

overridevirtual

Implements hw::device.

Definition at line 431 of file device_default.cpp.

                                                                                                                           {
 
          std::ostringstream s;
          binary_archive<true> a(s);
          ::serialization::serialize(a, const_cast<cryptonote::transaction_prefix&>(tx));
 
          crypto::cn_fast_hash(s.str().data(), s.str().size(), tx_prefix_hash);
 
          return true;
        }

get_type()

device_type hw::core::device_default::get_type ( ) const

inlineoverridevirtual

Implements hw::device.

Definition at line 64 of file device_default.hpp.

{return device_type::SOFTWARE;};

hash_to_scalar()

bool hw::core::device_default::hash_to_scalar ( boost::shared_ptr< crypto::rs_comm > buf, size_t length, crypto::ec_scalar & res )

overridevirtual

Implements hw::device.

Definition at line 426 of file device_default.cpp.

                                                                                                                   {
          crypto::hash_to_scalar(buf.get(), length, res);
          return true;
        }

init()

bool hw::core::device_default::init ( void )

overridevirtual

Implements hw::device.

Definition at line 72 of file device_default.cpp.

                                      {
            return true;
        }

lock()

void hw::core::device_default::lock ( void )

overridevirtual

Implements hw::device.

Definition at line 94 of file device_default.cpp.

{ }

mlsag_hash()

bool hw::core::device_default::mlsag_hash ( const rct::keyV & long_message, rct::key & c )

overridevirtual

Implements hw::device.

Definition at line 406 of file device_default.cpp.

                                                                            {
            c_old = rct::hash_to_scalar(toHash);
            return true;
        }

mlsag_prehash()

bool hw::core::device_default::mlsag_prehash ( const std::string & blob, size_t inputs_size, size_t outputs_size, const rct::keyV & hashes, const rct::ctkeyV & outPk, rct::key & prehash )

overridevirtual

Implements hw::device.

Definition at line 400 of file device_default.cpp.

                                                                                                                                                                          {
            prehash = rct::cn_fast_hash(hashes);
            return true;
        }

mlsag_prepare() [1/2]

bool hw::core::device_default::mlsag_prepare ( const rct::key & H, const rct::key & xx, rct::key & a, rct::key & aG, rct::key & aHP, rct::key & rvII )

overridevirtual

Implements hw::device.

Definition at line 389 of file device_default.cpp.

                                                                                         {
            rct::skpkGen(a, aG);
            rct::scalarmultKey(aHP, H, a);
            rct::scalarmultKey(II, H, xx);
            return true;
        }

mlsag_prepare() [2/2]

bool hw::core::device_default::mlsag_prepare ( rct::key & a, rct::key & aG )

overridevirtual

Implements hw::device.

Definition at line 396 of file device_default.cpp.

                                                                 {
            rct::skpkGen(a, aG);
            return true;
        }

mlsag_sign()

bool hw::core::device_default::mlsag_sign ( const rct::key & c, const rct::keyV & xx, const rct::keyV & alpha, const size_t rows, const size_t dsRows, rct::keyV & ss )

overridevirtual

Implements hw::device.

Definition at line 411 of file device_default.cpp.

                                                                                                                                                       {
            CHECK_AND_ASSERT_THROW_MES(dsRows<=rows, "dsRows greater than rows");
            CHECK_AND_ASSERT_THROW_MES(xx.size() == rows, "xx size does not match rows");
            CHECK_AND_ASSERT_THROW_MES(alpha.size() == rows, "alpha size does not match rows");
            CHECK_AND_ASSERT_THROW_MES(ss.size() == rows, "ss size does not match rows");
            for (size_t j = 0; j < rows; j++) {
                sc_mulsub(ss[j].bytes, c.bytes, xx[j].bytes, alpha[j].bytes);
            }
            return true;
        }

open_tx()

bool hw::core::device_default::open_tx ( crypto::secret_key & tx_key )

overridevirtual

Implements hw::device.

Definition at line 300 of file device_default.cpp.

                                                             {
            cryptonote::keypair txkey = cryptonote::keypair::generate(*this);
            tx_key = txkey.sec;
            return true;
        }

Here is the caller graph for this function:

operator bool()

hw::core::device_default::operator bool ( ) const

inlineexplicitoverridevirtual

Implements hw::device.

Definition at line 48 of file device_default.hpp.

{ return false; };

operator=()

device_default & hw::core::device_default::operator= ( const device_default & device )

delete

Here is the call graph for this function:

release()

bool hw::core::device_default::release ( )

overridevirtual

Implements hw::device.

Definition at line 75 of file device_default.cpp.

                                     {
            return true;
        }

sc_secret_add()

bool hw::core::device_default::sc_secret_add ( crypto::secret_key & r, const crypto::secret_key & a, const crypto::secret_key & b )

overridevirtual

Implements hw::device.

Definition at line 251 of file device_default.cpp.

                                                                                                                    {
            sc_add(&r, &a, &b);
            return true;
        }

Here is the caller graph for this function:

scalarmultBase()

bool hw::core::device_default::scalarmultBase ( rct::key & aG, const rct::key & a )

overridevirtual

Implements hw::device.

Definition at line 246 of file device_default.cpp.

                                                                       {
            rct::scalarmultBase(aG,a);
            return true;
        }

Here is the caller graph for this function:

scalarmultKey()

bool hw::core::device_default::scalarmultKey ( rct::key & aP, const rct::key & P, const rct::key & a )

overridevirtual

Implements hw::device.

Definition at line 241 of file device_default.cpp.

                                                                                        {
            rct::scalarmultKey(aP, P,a);
            return true;
        }

Here is the caller graph for this function:

secret_key_to_public_key()

bool hw::core::device_default::secret_key_to_public_key ( const crypto::secret_key & sec, crypto::public_key & pub )

overridevirtual

Implements hw::device.

Definition at line 278 of file device_default.cpp.

                                                                                                        {
            return crypto::secret_key_to_public_key(sec,pub);
        }

Here is the caller graph for this function:

set_mode()

bool hw::core::device_default::set_mode ( device_mode mode )

overridevirtual

Reimplemented from hw::device.

Definition at line 86 of file device_default.cpp.

                                                       {
            return device::set_mode(mode);
        }

Here is the call graph for this function:

set_name()

bool hw::core::device_default::set_name ( const std::string & name )

overridevirtual

Implements hw::device.

Definition at line 64 of file device_default.cpp.

                                                            {
            this->name = name;
            return true;
        }

Here is the caller graph for this function:

try_lock()

bool hw::core::device_default::try_lock ( void )

overridevirtual

Implements hw::device.

Definition at line 96 of file device_default.cpp.

{ return true; }

unlock()

void hw::core::device_default::unlock ( void )

overridevirtual

Implements hw::device.

Definition at line 98 of file device_default.cpp.

{ }

verify_keys()

bool hw::core::device_default::verify_keys ( const crypto::secret_key & secret_key, const crypto::public_key & public_key )

overridevirtual

Implements hw::device.

Definition at line 235 of file device_default.cpp.

                                                                                                                {
            crypto::public_key calculated_pub;
            bool r = crypto::secret_key_to_public_key(secret_key, calculated_pub);
            return r && public_key == calculated_pub;
        }

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device/device_default.hpp
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device/device_default.cpp