2017-02-21 17:38:18 +00:00
// Copyright (c) 2014-2017, The Monero Project
2014-07-23 13:03:52 +00:00
//
// 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.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
2014-03-03 22:07:58 +00:00
# include "include_base_utils.h"
using namespace epee ;
2017-03-01 22:27:27 +00:00
# include <atomic>
2017-11-25 14:50:15 +00:00
# include "wipeable_string.h"
2014-03-03 22:07:58 +00:00
# include "cryptonote_format_utils.h"
# include "cryptonote_config.h"
# include "crypto/crypto.h"
# include "crypto/hash.h"
2016-06-15 22:37:13 +00:00
# include "ringct/rctSigs.h"
2014-03-03 22:07:58 +00:00
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 16:34:23 +00:00
# undef MONERO_DEFAULT_LOG_CATEGORY
# define MONERO_DEFAULT_LOG_CATEGORY "cn"
2015-08-03 20:15:10 +00:00
# define ENCRYPTED_PAYMENT_ID_TAIL 0x8d
2017-03-22 18:01:09 +00:00
// #define ENABLE_HASH_CASH_INTEGRITY_CHECK
2017-10-10 14:47:08 +00:00
using namespace crypto ;
2015-10-06 14:58:09 +00:00
static const uint64_t valid_decomposed_outputs [ ] = {
( uint64_t ) 1 , ( uint64_t ) 2 , ( uint64_t ) 3 , ( uint64_t ) 4 , ( uint64_t ) 5 , ( uint64_t ) 6 , ( uint64_t ) 7 , ( uint64_t ) 8 , ( uint64_t ) 9 , // 1 piconero
( uint64_t ) 10 , ( uint64_t ) 20 , ( uint64_t ) 30 , ( uint64_t ) 40 , ( uint64_t ) 50 , ( uint64_t ) 60 , ( uint64_t ) 70 , ( uint64_t ) 80 , ( uint64_t ) 90 ,
( uint64_t ) 100 , ( uint64_t ) 200 , ( uint64_t ) 300 , ( uint64_t ) 400 , ( uint64_t ) 500 , ( uint64_t ) 600 , ( uint64_t ) 700 , ( uint64_t ) 800 , ( uint64_t ) 900 ,
( uint64_t ) 1000 , ( uint64_t ) 2000 , ( uint64_t ) 3000 , ( uint64_t ) 4000 , ( uint64_t ) 5000 , ( uint64_t ) 6000 , ( uint64_t ) 7000 , ( uint64_t ) 8000 , ( uint64_t ) 9000 ,
( uint64_t ) 10000 , ( uint64_t ) 20000 , ( uint64_t ) 30000 , ( uint64_t ) 40000 , ( uint64_t ) 50000 , ( uint64_t ) 60000 , ( uint64_t ) 70000 , ( uint64_t ) 80000 , ( uint64_t ) 90000 ,
( uint64_t ) 100000 , ( uint64_t ) 200000 , ( uint64_t ) 300000 , ( uint64_t ) 400000 , ( uint64_t ) 500000 , ( uint64_t ) 600000 , ( uint64_t ) 700000 , ( uint64_t ) 800000 , ( uint64_t ) 900000 ,
( uint64_t ) 1000000 , ( uint64_t ) 2000000 , ( uint64_t ) 3000000 , ( uint64_t ) 4000000 , ( uint64_t ) 5000000 , ( uint64_t ) 6000000 , ( uint64_t ) 7000000 , ( uint64_t ) 8000000 , ( uint64_t ) 9000000 , // 1 micronero
( uint64_t ) 10000000 , ( uint64_t ) 20000000 , ( uint64_t ) 30000000 , ( uint64_t ) 40000000 , ( uint64_t ) 50000000 , ( uint64_t ) 60000000 , ( uint64_t ) 70000000 , ( uint64_t ) 80000000 , ( uint64_t ) 90000000 ,
( uint64_t ) 100000000 , ( uint64_t ) 200000000 , ( uint64_t ) 300000000 , ( uint64_t ) 400000000 , ( uint64_t ) 500000000 , ( uint64_t ) 600000000 , ( uint64_t ) 700000000 , ( uint64_t ) 800000000 , ( uint64_t ) 900000000 ,
( uint64_t ) 1000000000 , ( uint64_t ) 2000000000 , ( uint64_t ) 3000000000 , ( uint64_t ) 4000000000 , ( uint64_t ) 5000000000 , ( uint64_t ) 6000000000 , ( uint64_t ) 7000000000 , ( uint64_t ) 8000000000 , ( uint64_t ) 9000000000 ,
( uint64_t ) 10000000000 , ( uint64_t ) 20000000000 , ( uint64_t ) 30000000000 , ( uint64_t ) 40000000000 , ( uint64_t ) 50000000000 , ( uint64_t ) 60000000000 , ( uint64_t ) 70000000000 , ( uint64_t ) 80000000000 , ( uint64_t ) 90000000000 ,
( uint64_t ) 100000000000 , ( uint64_t ) 200000000000 , ( uint64_t ) 300000000000 , ( uint64_t ) 400000000000 , ( uint64_t ) 500000000000 , ( uint64_t ) 600000000000 , ( uint64_t ) 700000000000 , ( uint64_t ) 800000000000 , ( uint64_t ) 900000000000 ,
( uint64_t ) 1000000000000 , ( uint64_t ) 2000000000000 , ( uint64_t ) 3000000000000 , ( uint64_t ) 4000000000000 , ( uint64_t ) 5000000000000 , ( uint64_t ) 6000000000000 , ( uint64_t ) 7000000000000 , ( uint64_t ) 8000000000000 , ( uint64_t ) 9000000000000 , // 1 monero
( uint64_t ) 10000000000000 , ( uint64_t ) 20000000000000 , ( uint64_t ) 30000000000000 , ( uint64_t ) 40000000000000 , ( uint64_t ) 50000000000000 , ( uint64_t ) 60000000000000 , ( uint64_t ) 70000000000000 , ( uint64_t ) 80000000000000 , ( uint64_t ) 90000000000000 ,
( uint64_t ) 100000000000000 , ( uint64_t ) 200000000000000 , ( uint64_t ) 300000000000000 , ( uint64_t ) 400000000000000 , ( uint64_t ) 500000000000000 , ( uint64_t ) 600000000000000 , ( uint64_t ) 700000000000000 , ( uint64_t ) 800000000000000 , ( uint64_t ) 900000000000000 ,
( uint64_t ) 1000000000000000 , ( uint64_t ) 2000000000000000 , ( uint64_t ) 3000000000000000 , ( uint64_t ) 4000000000000000 , ( uint64_t ) 5000000000000000 , ( uint64_t ) 6000000000000000 , ( uint64_t ) 7000000000000000 , ( uint64_t ) 8000000000000000 , ( uint64_t ) 9000000000000000 ,
( uint64_t ) 10000000000000000 , ( uint64_t ) 20000000000000000 , ( uint64_t ) 30000000000000000 , ( uint64_t ) 40000000000000000 , ( uint64_t ) 50000000000000000 , ( uint64_t ) 60000000000000000 , ( uint64_t ) 70000000000000000 , ( uint64_t ) 80000000000000000 , ( uint64_t ) 90000000000000000 ,
( uint64_t ) 100000000000000000 , ( uint64_t ) 200000000000000000 , ( uint64_t ) 300000000000000000 , ( uint64_t ) 400000000000000000 , ( uint64_t ) 500000000000000000 , ( uint64_t ) 600000000000000000 , ( uint64_t ) 700000000000000000 , ( uint64_t ) 800000000000000000 , ( uint64_t ) 900000000000000000 ,
( uint64_t ) 1000000000000000000 , ( uint64_t ) 2000000000000000000 , ( uint64_t ) 3000000000000000000 , ( uint64_t ) 4000000000000000000 , ( uint64_t ) 5000000000000000000 , ( uint64_t ) 6000000000000000000 , ( uint64_t ) 7000000000000000000 , ( uint64_t ) 8000000000000000000 , ( uint64_t ) 9000000000000000000 , // 1 meganero
( uint64_t ) 10000000000000000000ull
} ;
2017-03-01 22:27:27 +00:00
static std : : atomic < unsigned int > default_decimal_point ( CRYPTONOTE_DISPLAY_DECIMAL_POINT ) ;
2017-03-22 18:01:09 +00:00
static std : : atomic < uint64_t > tx_hashes_calculated_count ( 0 ) ;
static std : : atomic < uint64_t > tx_hashes_cached_count ( 0 ) ;
static std : : atomic < uint64_t > block_hashes_calculated_count ( 0 ) ;
static std : : atomic < uint64_t > block_hashes_cached_count ( 0 ) ;
2014-03-03 22:07:58 +00:00
namespace cryptonote
{
//---------------------------------------------------------------
void get_transaction_prefix_hash ( const transaction_prefix & tx , crypto : : hash & h )
{
std : : ostringstream s ;
binary_archive < true > a ( s ) ;
: : serialization : : serialize ( a , const_cast < transaction_prefix & > ( tx ) ) ;
crypto : : cn_fast_hash ( s . str ( ) . data ( ) , s . str ( ) . size ( ) , h ) ;
}
//---------------------------------------------------------------
crypto : : hash get_transaction_prefix_hash ( const transaction_prefix & tx )
{
crypto : : hash h = null_hash ;
get_transaction_prefix_hash ( tx , h ) ;
return h ;
}
//---------------------------------------------------------------
bool parse_and_validate_tx_from_blob ( const blobdata & tx_blob , transaction & tx )
{
std : : stringstream ss ;
ss < < tx_blob ;
binary_archive < false > ba ( ss ) ;
bool r = : : serialization : : serialize ( ba , tx ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to parse transaction from blob " ) ;
2017-03-25 09:18:53 +00:00
tx . invalidate_hashes ( ) ;
2014-03-03 22:07:58 +00:00
return true ;
}
//---------------------------------------------------------------
2017-02-27 20:24:39 +00:00
bool parse_and_validate_tx_base_from_blob ( const blobdata & tx_blob , transaction & tx )
{
std : : stringstream ss ;
ss < < tx_blob ;
binary_archive < false > ba ( ss ) ;
bool r = tx . serialize_base ( ba ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to parse transaction from blob " ) ;
return true ;
}
//---------------------------------------------------------------
2014-03-03 22:07:58 +00:00
bool parse_and_validate_tx_from_blob ( const blobdata & tx_blob , transaction & tx , crypto : : hash & tx_hash , crypto : : hash & tx_prefix_hash )
{
std : : stringstream ss ;
ss < < tx_blob ;
binary_archive < false > ba ( ss ) ;
bool r = : : serialization : : serialize ( ba , tx ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to parse transaction from blob " ) ;
2017-03-25 09:18:53 +00:00
tx . invalidate_hashes ( ) ;
2014-03-03 22:07:58 +00:00
//TODO: validate tx
2016-08-09 20:34:09 +00:00
get_transaction_hash ( tx , tx_hash ) ;
2014-03-03 22:07:58 +00:00
get_transaction_prefix_hash ( tx , tx_prefix_hash ) ;
return true ;
}
//---------------------------------------------------------------
2017-02-19 02:42:10 +00:00
crypto : : secret_key get_subaddress_secret_key ( const crypto : : secret_key & a , const subaddress_index & index )
{
const char prefix [ ] = " SubAddr " ;
char data [ sizeof ( prefix ) + sizeof ( crypto : : secret_key ) + sizeof ( subaddress_index ) ] ;
memcpy ( data , prefix , sizeof ( prefix ) ) ;
memcpy ( data + sizeof ( prefix ) , & a , sizeof ( crypto : : secret_key ) ) ;
memcpy ( data + sizeof ( prefix ) + sizeof ( crypto : : secret_key ) , & index , sizeof ( subaddress_index ) ) ;
crypto : : secret_key m ;
crypto : : hash_to_scalar ( data , sizeof ( data ) , m ) ;
return m ;
}
//---------------------------------------------------------------
bool generate_key_image_helper ( const account_keys & ack , const std : : unordered_map < crypto : : public_key , subaddress_index > & subaddresses , const crypto : : public_key & out_key , const crypto : : public_key & tx_public_key , const std : : vector < crypto : : public_key > & additional_tx_public_keys , size_t real_output_index , keypair & in_ephemeral , crypto : : key_image & ki )
2014-03-03 22:07:58 +00:00
{
crypto : : key_derivation recv_derivation = AUTO_VAL_INIT ( recv_derivation ) ;
bool r = crypto : : generate_key_derivation ( tx_public_key , ack . m_view_secret_key , recv_derivation ) ;
CHECK_AND_ASSERT_MES ( r , false , " key image helper: failed to generate_key_derivation( " < < tx_public_key < < " , " < < ack . m_view_secret_key < < " ) " ) ;
2017-02-19 02:42:10 +00:00
std : : vector < crypto : : key_derivation > additional_recv_derivations ;
for ( size_t i = 0 ; i < additional_tx_public_keys . size ( ) ; + + i )
{
crypto : : key_derivation additional_recv_derivation = AUTO_VAL_INIT ( additional_recv_derivation ) ;
r = crypto : : generate_key_derivation ( additional_tx_public_keys [ i ] , ack . m_view_secret_key , additional_recv_derivation ) ;
CHECK_AND_ASSERT_MES ( r , false , " key image helper: failed to generate_key_derivation( " < < additional_tx_public_keys [ i ] < < " , " < < ack . m_view_secret_key < < " ) " ) ;
additional_recv_derivations . push_back ( additional_recv_derivation ) ;
}
boost : : optional < subaddress_receive_info > subaddr_recv_info = is_out_to_acc_precomp ( subaddresses , out_key , recv_derivation , additional_recv_derivations , real_output_index ) ;
CHECK_AND_ASSERT_MES ( subaddr_recv_info , false , " key image helper: given output pubkey doesn't seem to belong to this address " ) ;
return generate_key_image_helper_precomp ( ack , out_key , subaddr_recv_info - > derivation , real_output_index , subaddr_recv_info - > index , in_ephemeral , ki ) ;
}
//---------------------------------------------------------------
bool generate_key_image_helper_precomp ( const account_keys & ack , const crypto : : public_key & out_key , const crypto : : key_derivation & recv_derivation , size_t real_output_index , const subaddress_index & received_index , keypair & in_ephemeral , crypto : : key_image & ki )
{
if ( ack . m_spend_secret_key = = crypto : : null_skey )
{
// for watch-only wallet, simply copy the known output pubkey
in_ephemeral . pub = out_key ;
in_ephemeral . sec = crypto : : null_skey ;
}
else
{
// derive secret key with subaddress - step 1: original CN derivation
crypto : : secret_key scalar_step1 ;
crypto : : derive_secret_key ( recv_derivation , real_output_index , ack . m_spend_secret_key , scalar_step1 ) ; // computes Hs(a*R || idx) + b
// step 2: add Hs(a || index_major || index_minor)
crypto : : secret_key scalar_step2 ;
if ( received_index . is_zero ( ) )
{
scalar_step2 = scalar_step1 ; // treat index=(0,0) as a special case representing the main address
}
else
{
crypto : : secret_key m = get_subaddress_secret_key ( ack . m_view_secret_key , received_index ) ;
sc_add ( ( unsigned char * ) & scalar_step2 , ( unsigned char * ) & scalar_step1 , ( unsigned char * ) & m ) ;
}
2014-03-03 22:07:58 +00:00
2017-02-19 02:42:10 +00:00
in_ephemeral . sec = scalar_step2 ;
crypto : : secret_key_to_public_key ( in_ephemeral . sec , in_ephemeral . pub ) ;
CHECK_AND_ASSERT_MES ( in_ephemeral . pub = = out_key , false , " key image helper precomp: given output pubkey doesn't match the derived one " ) ;
}
2014-03-03 22:07:58 +00:00
crypto : : generate_key_image ( in_ephemeral . pub , in_ephemeral . sec , ki ) ;
return true ;
}
//---------------------------------------------------------------
uint64_t power_integral ( uint64_t a , uint64_t b )
{
if ( b = = 0 )
return 1 ;
uint64_t total = a ;
for ( uint64_t i = 1 ; i ! = b ; i + + )
total * = a ;
return total ;
}
//---------------------------------------------------------------
bool parse_amount ( uint64_t & amount , const std : : string & str_amount_ )
{
std : : string str_amount = str_amount_ ;
boost : : algorithm : : trim ( str_amount ) ;
2014-04-02 16:00:17 +00:00
size_t point_index = str_amount . find_first_of ( ' . ' ) ;
size_t fraction_size ;
if ( std : : string : : npos ! = point_index )
2014-03-03 22:07:58 +00:00
{
2014-04-02 16:00:17 +00:00
fraction_size = str_amount . size ( ) - point_index - 1 ;
2017-03-01 22:27:27 +00:00
while ( default_decimal_point < fraction_size & & ' 0 ' = = str_amount . back ( ) )
2014-04-02 16:00:17 +00:00
{
str_amount . erase ( str_amount . size ( ) - 1 , 1 ) ;
- - fraction_size ;
}
2017-03-01 22:27:27 +00:00
if ( default_decimal_point < fraction_size )
2014-03-03 22:07:58 +00:00
return false ;
2014-04-02 16:00:17 +00:00
str_amount . erase ( point_index , 1 ) ;
2014-03-03 22:07:58 +00:00
}
2014-04-02 16:00:17 +00:00
else
{
fraction_size = 0 ;
}
if ( str_amount . empty ( ) )
return false ;
2017-03-01 22:27:27 +00:00
if ( fraction_size < default_decimal_point )
2014-04-02 16:00:17 +00:00
{
2017-03-01 22:27:27 +00:00
str_amount . append ( default_decimal_point - fraction_size , ' 0 ' ) ;
2014-04-02 16:00:17 +00:00
}
return string_tools : : get_xtype_from_string ( amount , str_amount ) ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
bool get_tx_fee ( const transaction & tx , uint64_t & fee )
{
2016-06-15 22:37:13 +00:00
if ( tx . version > 1 )
{
fee = tx . rct_signatures . txnFee ;
return true ;
}
2014-03-03 22:07:58 +00:00
uint64_t amount_in = 0 ;
uint64_t amount_out = 0 ;
2017-01-22 20:38:10 +00:00
for ( auto & in : tx . vin )
2014-03-03 22:07:58 +00:00
{
CHECK_AND_ASSERT_MES ( in . type ( ) = = typeid ( txin_to_key ) , 0 , " unexpected type id in transaction " ) ;
amount_in + = boost : : get < txin_to_key > ( in ) . amount ;
}
2017-01-22 20:38:10 +00:00
for ( auto & o : tx . vout )
2014-03-03 22:07:58 +00:00
amount_out + = o . amount ;
CHECK_AND_ASSERT_MES ( amount_in > = amount_out , false , " transaction spend ( " < < amount_in < < " ) more than it has ( " < < amount_out < < " ) " ) ;
fee = amount_in - amount_out ;
return true ;
}
//---------------------------------------------------------------
uint64_t get_tx_fee ( const transaction & tx )
{
uint64_t r = 0 ;
if ( ! get_tx_fee ( tx , r ) )
return 0 ;
return r ;
}
//---------------------------------------------------------------
2014-05-03 16:19:43 +00:00
bool parse_tx_extra ( const std : : vector < uint8_t > & tx_extra , std : : vector < tx_extra_field > & tx_extra_fields )
2014-03-03 22:07:58 +00:00
{
2014-05-03 16:19:43 +00:00
tx_extra_fields . clear ( ) ;
if ( tx_extra . empty ( ) )
return true ;
std : : string extra_str ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ;
std : : istringstream iss ( extra_str ) ;
binary_archive < false > ar ( iss ) ;
bool eof = false ;
while ( ! eof )
2014-03-03 22:07:58 +00:00
{
2014-05-03 16:19:43 +00:00
tx_extra_field field ;
bool r = : : do_serialize ( ar , field ) ;
2016-04-30 15:10:10 +00:00
CHECK_AND_NO_ASSERT_MES_L1 ( r , false , " failed to deserialize extra field. extra = " < < string_tools : : buff_to_hex_nodelimer ( std : : string ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ) ) ;
2014-05-03 16:19:43 +00:00
tx_extra_fields . push_back ( field ) ;
std : : ios_base : : iostate state = iss . rdstate ( ) ;
eof = ( EOF = = iss . peek ( ) ) ;
iss . clear ( state ) ;
2014-03-03 22:07:58 +00:00
}
2016-04-30 15:10:10 +00:00
CHECK_AND_NO_ASSERT_MES_L1 ( : : serialization : : check_stream_state ( ar ) , false , " failed to deserialize extra field. extra = " < < string_tools : : buff_to_hex_nodelimer ( std : : string ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ) ) ;
2014-05-03 16:19:43 +00:00
2014-03-03 22:07:58 +00:00
return true ;
}
//---------------------------------------------------------------
2016-12-09 18:21:21 +00:00
crypto : : public_key get_tx_pub_key_from_extra ( const std : : vector < uint8_t > & tx_extra , size_t pk_index )
2014-05-03 16:19:43 +00:00
{
std : : vector < tx_extra_field > tx_extra_fields ;
2014-05-25 17:06:40 +00:00
parse_tx_extra ( tx_extra , tx_extra_fields ) ;
2014-05-03 16:19:43 +00:00
tx_extra_pub_key pub_key_field ;
2016-12-09 18:21:21 +00:00
if ( ! find_tx_extra_field_by_type ( tx_extra_fields , pub_key_field , pk_index ) )
2014-05-03 16:19:43 +00:00
return null_pkey ;
return pub_key_field . pub_key ;
}
//---------------------------------------------------------------
2016-12-09 18:21:21 +00:00
crypto : : public_key get_tx_pub_key_from_extra ( const transaction_prefix & tx_prefix , size_t pk_index )
2016-08-06 18:19:25 +00:00
{
2016-12-09 18:21:21 +00:00
return get_tx_pub_key_from_extra ( tx_prefix . extra , pk_index ) ;
2016-08-06 18:19:25 +00:00
}
//---------------------------------------------------------------
2016-12-09 18:21:21 +00:00
crypto : : public_key get_tx_pub_key_from_extra ( const transaction & tx , size_t pk_index )
2014-05-03 16:19:43 +00:00
{
2016-12-09 18:21:21 +00:00
return get_tx_pub_key_from_extra ( tx . extra , pk_index ) ;
2014-05-03 16:19:43 +00:00
}
//---------------------------------------------------------------
2014-03-03 22:07:58 +00:00
bool add_tx_pub_key_to_extra ( transaction & tx , const crypto : : public_key & tx_pub_key )
{
2017-08-04 17:05:35 +00:00
return add_tx_pub_key_to_extra ( tx . extra , tx_pub_key ) ;
}
//---------------------------------------------------------------
bool add_tx_pub_key_to_extra ( transaction_prefix & tx , const crypto : : public_key & tx_pub_key )
{
return add_tx_pub_key_to_extra ( tx . extra , tx_pub_key ) ;
}
//---------------------------------------------------------------
bool add_tx_pub_key_to_extra ( std : : vector < uint8_t > & tx_extra , const crypto : : public_key & tx_pub_key )
{
tx_extra . resize ( tx_extra . size ( ) + 1 + sizeof ( crypto : : public_key ) ) ;
tx_extra [ tx_extra . size ( ) - 1 - sizeof ( crypto : : public_key ) ] = TX_EXTRA_TAG_PUBKEY ;
* reinterpret_cast < crypto : : public_key * > ( & tx_extra [ tx_extra . size ( ) - sizeof ( crypto : : public_key ) ] ) = tx_pub_key ;
2014-03-03 22:07:58 +00:00
return true ;
}
//---------------------------------------------------------------
2017-02-19 02:42:10 +00:00
std : : vector < crypto : : public_key > get_additional_tx_pub_keys_from_extra ( const std : : vector < uint8_t > & tx_extra )
{
// parse
std : : vector < tx_extra_field > tx_extra_fields ;
parse_tx_extra ( tx_extra , tx_extra_fields ) ;
// find corresponding field
tx_extra_additional_pub_keys additional_pub_keys ;
if ( ! find_tx_extra_field_by_type ( tx_extra_fields , additional_pub_keys ) )
return { } ;
return additional_pub_keys . data ;
}
//---------------------------------------------------------------
std : : vector < crypto : : public_key > get_additional_tx_pub_keys_from_extra ( const transaction_prefix & tx )
{
return get_additional_tx_pub_keys_from_extra ( tx . extra ) ;
}
//---------------------------------------------------------------
bool add_additional_tx_pub_keys_to_extra ( std : : vector < uint8_t > & tx_extra , const std : : vector < crypto : : public_key > & additional_pub_keys )
{
// convert to variant
tx_extra_field field = tx_extra_additional_pub_keys { additional_pub_keys } ;
// serialize
std : : ostringstream oss ;
binary_archive < true > ar ( oss ) ;
bool r = : : do_serialize ( ar , field ) ;
CHECK_AND_NO_ASSERT_MES_L1 ( r , false , " failed to serialize tx extra additional tx pub keys " ) ;
// append
std : : string tx_extra_str = oss . str ( ) ;
size_t pos = tx_extra . size ( ) ;
tx_extra . resize ( tx_extra . size ( ) + tx_extra_str . size ( ) ) ;
memcpy ( & tx_extra [ pos ] , tx_extra_str . data ( ) , tx_extra_str . size ( ) ) ;
return true ;
}
//---------------------------------------------------------------
2014-05-03 16:19:43 +00:00
bool add_extra_nonce_to_tx_extra ( std : : vector < uint8_t > & tx_extra , const blobdata & extra_nonce )
2014-03-03 22:07:58 +00:00
{
2014-05-03 16:19:43 +00:00
CHECK_AND_ASSERT_MES ( extra_nonce . size ( ) < = TX_EXTRA_NONCE_MAX_COUNT , false , " extra nonce could be 255 bytes max " ) ;
size_t start_pos = tx_extra . size ( ) ;
tx_extra . resize ( tx_extra . size ( ) + 2 + extra_nonce . size ( ) ) ;
2014-03-03 22:07:58 +00:00
//write tag
2014-05-03 16:19:43 +00:00
tx_extra [ start_pos ] = TX_EXTRA_NONCE ;
2014-03-03 22:07:58 +00:00
//write len
+ + start_pos ;
2014-05-03 16:19:43 +00:00
tx_extra [ start_pos ] = static_cast < uint8_t > ( extra_nonce . size ( ) ) ;
2014-03-03 22:07:58 +00:00
//write data
+ + start_pos ;
2014-05-03 16:19:43 +00:00
memcpy ( & tx_extra [ start_pos ] , extra_nonce . data ( ) , extra_nonce . size ( ) ) ;
return true ;
}
//---------------------------------------------------------------
2015-08-12 22:05:53 +00:00
bool remove_field_from_tx_extra ( std : : vector < uint8_t > & tx_extra , const std : : type_info & type )
2015-08-03 20:15:10 +00:00
{
2017-01-07 16:05:02 +00:00
if ( tx_extra . empty ( ) )
return true ;
2015-08-03 20:15:10 +00:00
std : : string extra_str ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ;
std : : istringstream iss ( extra_str ) ;
binary_archive < false > ar ( iss ) ;
std : : ostringstream oss ;
binary_archive < true > newar ( oss ) ;
bool eof = false ;
while ( ! eof )
{
tx_extra_field field ;
bool r = : : do_serialize ( ar , field ) ;
2016-04-30 15:10:10 +00:00
CHECK_AND_NO_ASSERT_MES_L1 ( r , false , " failed to deserialize extra field. extra = " < < string_tools : : buff_to_hex_nodelimer ( std : : string ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ) ) ;
2015-08-12 22:05:53 +00:00
if ( field . type ( ) ! = type )
2015-08-03 20:15:10 +00:00
: : do_serialize ( newar , field ) ;
std : : ios_base : : iostate state = iss . rdstate ( ) ;
eof = ( EOF = = iss . peek ( ) ) ;
iss . clear ( state ) ;
}
2016-04-30 15:10:10 +00:00
CHECK_AND_NO_ASSERT_MES_L1 ( : : serialization : : check_stream_state ( ar ) , false , " failed to deserialize extra field. extra = " < < string_tools : : buff_to_hex_nodelimer ( std : : string ( reinterpret_cast < const char * > ( tx_extra . data ( ) ) , tx_extra . size ( ) ) ) ) ;
2015-08-03 20:15:10 +00:00
tx_extra . clear ( ) ;
std : : string s = oss . str ( ) ;
tx_extra . reserve ( s . size ( ) ) ;
std : : copy ( s . begin ( ) , s . end ( ) , std : : back_inserter ( tx_extra ) ) ;
return true ;
}
//---------------------------------------------------------------
2015-08-09 09:09:39 +00:00
void set_payment_id_to_tx_extra_nonce ( blobdata & extra_nonce , const crypto : : hash & payment_id )
2014-05-03 16:19:43 +00:00
{
extra_nonce . clear ( ) ;
2015-08-09 09:09:39 +00:00
extra_nonce . push_back ( TX_EXTRA_NONCE_PAYMENT_ID ) ;
2014-05-03 16:19:43 +00:00
const uint8_t * payment_id_ptr = reinterpret_cast < const uint8_t * > ( & payment_id ) ;
std : : copy ( payment_id_ptr , payment_id_ptr + sizeof ( payment_id ) , std : : back_inserter ( extra_nonce ) ) ;
}
//---------------------------------------------------------------
2015-08-09 09:09:39 +00:00
void set_encrypted_payment_id_to_tx_extra_nonce ( blobdata & extra_nonce , const crypto : : hash8 & payment_id )
{
extra_nonce . clear ( ) ;
extra_nonce . push_back ( TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID ) ;
const uint8_t * payment_id_ptr = reinterpret_cast < const uint8_t * > ( & payment_id ) ;
std : : copy ( payment_id_ptr , payment_id_ptr + sizeof ( payment_id ) , std : : back_inserter ( extra_nonce ) ) ;
}
//---------------------------------------------------------------
bool get_payment_id_from_tx_extra_nonce ( const blobdata & extra_nonce , crypto : : hash & payment_id )
2014-05-03 16:19:43 +00:00
{
if ( sizeof ( crypto : : hash ) + 1 ! = extra_nonce . size ( ) )
return false ;
2015-08-09 09:09:39 +00:00
if ( TX_EXTRA_NONCE_PAYMENT_ID ! = extra_nonce [ 0 ] )
2014-05-03 16:19:43 +00:00
return false ;
payment_id = * reinterpret_cast < const crypto : : hash * > ( extra_nonce . data ( ) + 1 ) ;
2015-08-03 20:15:10 +00:00
return true ;
}
//---------------------------------------------------------------
2015-08-09 09:09:39 +00:00
bool get_encrypted_payment_id_from_tx_extra_nonce ( const blobdata & extra_nonce , crypto : : hash8 & payment_id )
{
if ( sizeof ( crypto : : hash8 ) + 1 ! = extra_nonce . size ( ) )
return false ;
if ( TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID ! = extra_nonce [ 0 ] )
return false ;
payment_id = * reinterpret_cast < const crypto : : hash8 * > ( extra_nonce . data ( ) + 1 ) ;
return true ;
}
//---------------------------------------------------------------
bool encrypt_payment_id ( crypto : : hash8 & payment_id , const crypto : : public_key & public_key , const crypto : : secret_key & secret_key )
2015-08-03 20:15:10 +00:00
{
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 ) ;
2015-08-09 09:09:39 +00:00
for ( size_t b = 0 ; b < 8 ; + + b )
2015-08-03 20:15:10 +00:00
payment_id . data [ b ] ^ = hash . data [ b ] ;
2014-03-03 22:07:58 +00:00
return true ;
}
2015-08-09 09:09:39 +00:00
bool decrypt_payment_id ( crypto : : hash8 & payment_id , const crypto : : public_key & public_key , const crypto : : secret_key & secret_key )
2015-08-03 20:15:10 +00:00
{
// Encryption and decryption are the same operation (xor with a key)
return encrypt_payment_id ( payment_id , public_key , secret_key ) ;
}
2014-03-03 22:07:58 +00:00
//---------------------------------------------------------------
bool get_inputs_money_amount ( const transaction & tx , uint64_t & money )
{
money = 0 ;
2017-01-22 20:38:10 +00:00
for ( const auto & in : tx . vin )
2014-03-03 22:07:58 +00:00
{
CHECKED_GET_SPECIFIC_VARIANT ( in , const txin_to_key , tokey_in , false ) ;
money + = tokey_in . amount ;
}
return true ;
}
//---------------------------------------------------------------
uint64_t get_block_height ( const block & b )
{
CHECK_AND_ASSERT_MES ( b . miner_tx . vin . size ( ) = = 1 , 0 , " wrong miner tx in block: " < < get_block_hash ( b ) < < " , b.miner_tx.vin.size() != 1 " ) ;
CHECKED_GET_SPECIFIC_VARIANT ( b . miner_tx . vin [ 0 ] , const txin_gen , coinbase_in , 0 ) ;
return coinbase_in . height ;
}
//---------------------------------------------------------------
bool check_inputs_types_supported ( const transaction & tx )
{
2017-01-22 20:38:10 +00:00
for ( const auto & in : tx . vin )
2014-03-03 22:07:58 +00:00
{
CHECK_AND_ASSERT_MES ( in . type ( ) = = typeid ( txin_to_key ) , false , " wrong variant type: "
< < in . type ( ) . name ( ) < < " , expected " < < typeid ( txin_to_key ) . name ( )
< < " , in transaction id= " < < get_transaction_hash ( tx ) ) ;
}
return true ;
}
//-----------------------------------------------------------------------------------------------
bool check_outs_valid ( const transaction & tx )
{
2017-01-22 20:38:10 +00:00
for ( const tx_out & out : tx . vout )
2014-03-03 22:07:58 +00:00
{
CHECK_AND_ASSERT_MES ( out . target . type ( ) = = typeid ( txout_to_key ) , false , " wrong variant type: "
< < out . target . type ( ) . name ( ) < < " , expected " < < typeid ( txout_to_key ) . name ( )
< < " , in transaction id= " < < get_transaction_hash ( tx ) ) ;
2016-06-15 22:37:13 +00:00
if ( tx . version = = 1 )
{
CHECK_AND_NO_ASSERT_MES ( 0 < out . amount , false , " zero amount output in transaction id= " < < get_transaction_hash ( tx ) ) ;
}
2014-03-03 22:07:58 +00:00
if ( ! check_key ( boost : : get < txout_to_key > ( out . target ) . key ) )
return false ;
}
return true ;
}
//-----------------------------------------------------------------------------------------------
bool check_money_overflow ( const transaction & tx )
{
return check_inputs_overflow ( tx ) & & check_outs_overflow ( tx ) ;
}
//---------------------------------------------------------------
bool check_inputs_overflow ( const transaction & tx )
{
uint64_t money = 0 ;
2017-01-22 20:38:10 +00:00
for ( const auto & in : tx . vin )
2014-03-03 22:07:58 +00:00
{
CHECKED_GET_SPECIFIC_VARIANT ( in , const txin_to_key , tokey_in , false ) ;
if ( money > tokey_in . amount + money )
return false ;
money + = tokey_in . amount ;
}
return true ;
}
//---------------------------------------------------------------
bool check_outs_overflow ( const transaction & tx )
{
uint64_t money = 0 ;
2017-01-22 20:38:10 +00:00
for ( const auto & o : tx . vout )
2014-03-03 22:07:58 +00:00
{
if ( money > o . amount + money )
return false ;
money + = o . amount ;
}
return true ;
}
//---------------------------------------------------------------
uint64_t get_outs_money_amount ( const transaction & tx )
{
uint64_t outputs_amount = 0 ;
2017-01-22 20:38:10 +00:00
for ( const auto & o : tx . vout )
2014-03-03 22:07:58 +00:00
outputs_amount + = o . amount ;
return outputs_amount ;
}
//---------------------------------------------------------------
std : : string short_hash_str ( const crypto : : hash & h )
{
std : : string res = string_tools : : pod_to_hex ( h ) ;
CHECK_AND_ASSERT_MES ( res . size ( ) = = 64 , res , " wrong hash256 with string_tools::pod_to_hex conversion " ) ;
auto erased_pos = res . erase ( 8 , 48 ) ;
res . insert ( 8 , " .... " ) ;
return res ;
}
//---------------------------------------------------------------
2017-02-19 02:42:10 +00:00
bool is_out_to_acc ( const account_keys & acc , const txout_to_key & out_key , const crypto : : public_key & tx_pub_key , const std : : vector < crypto : : public_key > & additional_tx_pub_keys , size_t output_index )
2014-03-03 22:07:58 +00:00
{
crypto : : key_derivation derivation ;
generate_key_derivation ( tx_pub_key , acc . m_view_secret_key , derivation ) ;
crypto : : public_key pk ;
derive_public_key ( derivation , output_index , acc . m_account_address . m_spend_public_key , pk ) ;
2017-02-19 02:42:10 +00:00
if ( pk = = out_key . key )
return true ;
// try additional tx pubkeys if available
if ( ! additional_tx_pub_keys . empty ( ) )
{
CHECK_AND_ASSERT_MES ( output_index < additional_tx_pub_keys . size ( ) , false , " wrong number of additional tx pubkeys " ) ;
generate_key_derivation ( additional_tx_pub_keys [ output_index ] , acc . m_view_secret_key , derivation ) ;
derive_public_key ( derivation , output_index , acc . m_account_address . m_spend_public_key , pk ) ;
return pk = = out_key . key ;
}
return false ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
2017-02-19 02:42:10 +00:00
boost : : optional < subaddress_receive_info > is_out_to_acc_precomp ( const std : : unordered_map < crypto : : public_key , subaddress_index > & subaddresses , const crypto : : public_key & out_key , const crypto : : key_derivation & derivation , const std : : vector < crypto : : key_derivation > & additional_derivations , size_t output_index )
2016-11-01 16:24:04 +00:00
{
2017-02-19 02:42:10 +00:00
// try the shared tx pubkey
crypto : : public_key subaddress_spendkey ;
derive_subaddress_public_key ( out_key , derivation , output_index , subaddress_spendkey ) ;
auto found = subaddresses . find ( subaddress_spendkey ) ;
if ( found ! = subaddresses . end ( ) )
return subaddress_receive_info { found - > second , derivation } ;
// try additional tx pubkeys if available
if ( ! additional_derivations . empty ( ) )
{
CHECK_AND_ASSERT_MES ( output_index < additional_derivations . size ( ) , boost : : none , " wrong number of additional derivations " ) ;
derive_subaddress_public_key ( out_key , additional_derivations [ output_index ] , output_index , subaddress_spendkey ) ;
found = subaddresses . find ( subaddress_spendkey ) ;
if ( found ! = subaddresses . end ( ) )
return subaddress_receive_info { found - > second , additional_derivations [ output_index ] } ;
}
return boost : : none ;
2016-11-01 16:24:04 +00:00
}
//---------------------------------------------------------------
2014-03-03 22:07:58 +00:00
bool lookup_acc_outs ( const account_keys & acc , const transaction & tx , std : : vector < size_t > & outs , uint64_t & money_transfered )
{
2014-05-03 16:19:43 +00:00
crypto : : public_key tx_pub_key = get_tx_pub_key_from_extra ( tx ) ;
if ( null_pkey = = tx_pub_key )
return false ;
2017-02-19 02:42:10 +00:00
std : : vector < crypto : : public_key > additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra ( tx ) ;
return lookup_acc_outs ( acc , tx , tx_pub_key , additional_tx_pub_keys , outs , money_transfered ) ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
2017-02-19 02:42:10 +00:00
bool lookup_acc_outs ( const account_keys & acc , const transaction & tx , const crypto : : public_key & tx_pub_key , const std : : vector < crypto : : public_key > & additional_tx_pub_keys , std : : vector < size_t > & outs , uint64_t & money_transfered )
2014-03-03 22:07:58 +00:00
{
2017-02-19 02:42:10 +00:00
CHECK_AND_ASSERT_MES ( additional_tx_pub_keys . empty ( ) | | additional_tx_pub_keys . size ( ) = = tx . vout . size ( ) , false , " wrong number of additional pubkeys " ) ;
2014-03-03 22:07:58 +00:00
money_transfered = 0 ;
size_t i = 0 ;
2017-01-22 20:38:10 +00:00
for ( const tx_out & o : tx . vout )
2014-03-03 22:07:58 +00:00
{
CHECK_AND_ASSERT_MES ( o . target . type ( ) = = typeid ( txout_to_key ) , false , " wrong type id in transaction out " ) ;
2017-02-19 02:42:10 +00:00
if ( is_out_to_acc ( acc , boost : : get < txout_to_key > ( o . target ) , tx_pub_key , additional_tx_pub_keys , i ) )
2014-03-03 22:07:58 +00:00
{
outs . push_back ( i ) ;
money_transfered + = o . amount ;
}
i + + ;
}
return true ;
}
//---------------------------------------------------------------
void get_blob_hash ( const blobdata & blob , crypto : : hash & res )
{
cn_fast_hash ( blob . data ( ) , blob . size ( ) , res ) ;
}
//---------------------------------------------------------------
2017-03-01 22:27:27 +00:00
void set_default_decimal_point ( unsigned int decimal_point )
{
switch ( decimal_point )
{
case 12 :
case 9 :
case 6 :
case 3 :
case 0 :
default_decimal_point = decimal_point ;
break ;
default :
2017-03-04 22:11:44 +00:00
ASSERT_MES_AND_THROW ( " Invalid decimal point specification: " < < decimal_point ) ;
2017-03-01 22:27:27 +00:00
}
}
//---------------------------------------------------------------
unsigned int get_default_decimal_point ( )
{
return default_decimal_point ;
}
//---------------------------------------------------------------
std : : string get_unit ( unsigned int decimal_point )
{
if ( decimal_point = = ( unsigned int ) - 1 )
decimal_point = default_decimal_point ;
switch ( std : : atomic_load ( & default_decimal_point ) )
{
case 12 :
return " monero " ;
case 9 :
return " millinero " ;
case 6 :
return " micronero " ;
case 3 :
return " nanonero " ;
case 0 :
return " piconero " ;
default :
2017-03-04 22:11:44 +00:00
ASSERT_MES_AND_THROW ( " Invalid decimal point specification: " < < default_decimal_point ) ;
2017-03-01 22:27:27 +00:00
}
}
//---------------------------------------------------------------
std : : string print_money ( uint64_t amount , unsigned int decimal_point )
2014-03-03 22:07:58 +00:00
{
2017-03-01 22:27:27 +00:00
if ( decimal_point = = ( unsigned int ) - 1 )
decimal_point = default_decimal_point ;
2014-03-03 22:07:58 +00:00
std : : string s = std : : to_string ( amount ) ;
2017-03-01 22:27:27 +00:00
if ( s . size ( ) < decimal_point + 1 )
2014-03-03 22:07:58 +00:00
{
2017-03-01 22:27:27 +00:00
s . insert ( 0 , decimal_point + 1 - s . size ( ) , ' 0 ' ) ;
2014-03-03 22:07:58 +00:00
}
2017-03-01 22:27:27 +00:00
if ( decimal_point > 0 )
s . insert ( s . size ( ) - decimal_point , " . " ) ;
2014-03-03 22:07:58 +00:00
return s ;
}
//---------------------------------------------------------------
crypto : : hash get_blob_hash ( const blobdata & blob )
{
crypto : : hash h = null_hash ;
get_blob_hash ( blob , h ) ;
return h ;
}
//---------------------------------------------------------------
crypto : : hash get_transaction_hash ( const transaction & t )
{
crypto : : hash h = null_hash ;
2016-08-09 20:34:09 +00:00
get_transaction_hash ( t , h , NULL ) ;
2014-03-03 22:07:58 +00:00
return h ;
}
//---------------------------------------------------------------
bool get_transaction_hash ( const transaction & t , crypto : : hash & res )
{
2016-08-09 20:34:09 +00:00
return get_transaction_hash ( t , res , NULL ) ;
}
//---------------------------------------------------------------
2017-03-22 18:01:09 +00:00
bool calculate_transaction_hash ( const transaction & t , crypto : : hash & res , size_t * blob_size )
2016-08-09 20:34:09 +00:00
{
// v1 transactions hash the entire blob
if ( t . version = = 1 )
{
size_t ignored_blob_size , & blob_size_ref = blob_size ? * blob_size : ignored_blob_size ;
return get_object_hash ( t , res , blob_size_ref ) ;
}
// v2 transactions hash different parts together, than hash the set of those hashes
crypto : : hash hashes [ 3 ] ;
// prefix
get_transaction_prefix_hash ( t , hashes [ 0 ] ) ;
2016-09-14 19:23:06 +00:00
transaction & tt = const_cast < transaction & > ( t ) ;
2016-08-09 20:34:09 +00:00
2016-09-14 19:23:06 +00:00
// base rct
{
std : : stringstream ss ;
binary_archive < true > ba ( ss ) ;
const size_t inputs = t . vin . size ( ) ;
const size_t outputs = t . vout . size ( ) ;
bool r = tt . rct_signatures . serialize_rctsig_base ( ba , inputs , outputs ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to serialize rct signatures base " ) ;
cryptonote : : get_blob_hash ( ss . str ( ) , hashes [ 1 ] ) ;
}
// prunable rct
if ( t . rct_signatures . type = = rct : : RCTTypeNull )
{
2017-09-10 16:35:59 +00:00
hashes [ 2 ] = crypto : : null_hash ;
2016-09-14 19:23:06 +00:00
}
else
{
std : : stringstream ss ;
binary_archive < true > ba ( ss ) ;
const size_t inputs = t . vin . size ( ) ;
const size_t outputs = t . vout . size ( ) ;
const size_t mixin = t . vin . empty ( ) ? 0 : t . vin [ 0 ] . type ( ) = = typeid ( txin_to_key ) ? boost : : get < txin_to_key > ( t . vin [ 0 ] ) . key_offsets . size ( ) - 1 : 0 ;
bool r = tt . rct_signatures . p . serialize_rctsig_prunable ( ba , t . rct_signatures . type , inputs , outputs , mixin ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to serialize rct signatures prunable " ) ;
cryptonote : : get_blob_hash ( ss . str ( ) , hashes [ 2 ] ) ;
}
2016-08-09 20:34:09 +00:00
// the tx hash is the hash of the 3 hashes
res = cn_fast_hash ( hashes , sizeof ( hashes ) ) ;
// we still need the size
if ( blob_size )
* blob_size = get_object_blobsize ( t ) ;
return true ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
2017-03-22 18:01:09 +00:00
bool get_transaction_hash ( const transaction & t , crypto : : hash & res , size_t * blob_size )
{
2017-03-25 09:18:53 +00:00
if ( t . is_hash_valid ( ) )
2017-03-22 18:01:09 +00:00
{
# ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
CHECK_AND_ASSERT_THROW_MES ( ! calculate_transaction_hash ( t , res , blob_size ) | | t . hash = = res , " tx hash cash integrity failure " ) ;
# endif
res = t . hash ;
if ( blob_size )
{
2017-03-25 09:18:53 +00:00
if ( ! t . is_blob_size_valid ( ) )
2017-03-22 18:01:09 +00:00
{
t . blob_size = get_object_blobsize ( t ) ;
2017-03-25 09:18:53 +00:00
t . set_blob_size_valid ( true ) ;
2017-03-22 18:01:09 +00:00
}
* blob_size = t . blob_size ;
}
+ + tx_hashes_cached_count ;
return true ;
}
+ + tx_hashes_calculated_count ;
bool ret = calculate_transaction_hash ( t , res , blob_size ) ;
if ( ! ret )
return false ;
t . hash = res ;
2017-03-25 09:18:53 +00:00
t . set_hash_valid ( true ) ;
2017-03-22 18:01:09 +00:00
if ( blob_size )
{
t . blob_size = * blob_size ;
2017-03-25 09:18:53 +00:00
t . set_blob_size_valid ( true ) ;
2017-03-22 18:01:09 +00:00
}
return true ;
}
//---------------------------------------------------------------
2014-03-03 22:07:58 +00:00
bool get_transaction_hash ( const transaction & t , crypto : : hash & res , size_t & blob_size )
{
2016-08-09 20:34:09 +00:00
return get_transaction_hash ( t , res , & blob_size ) ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
blobdata get_block_hashing_blob ( const block & b )
{
blobdata blob = t_serializable_object_to_blob ( static_cast < block_header > ( b ) ) ;
2014-04-02 16:00:17 +00:00
crypto : : hash tree_root_hash = get_tx_tree_hash ( b ) ;
2014-06-30 19:17:24 +00:00
blob . append ( reinterpret_cast < const char * > ( & tree_root_hash ) , sizeof ( tree_root_hash ) ) ;
2014-03-03 22:07:58 +00:00
blob . append ( tools : : get_varint_data ( b . tx_hashes . size ( ) + 1 ) ) ;
return blob ;
}
//---------------------------------------------------------------
2017-03-22 18:01:09 +00:00
bool calculate_block_hash ( const block & b , crypto : : hash & res )
2014-03-03 22:07:58 +00:00
{
2014-09-05 22:06:08 +00:00
// EXCEPTION FOR BLOCK 202612
const std : : string correct_blob_hash_202612 = " 3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966 " ;
const std : : string existing_block_id_202612 = " bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698 " ;
crypto : : hash block_blob_hash = get_blob_hash ( block_to_blob ( b ) ) ;
if ( string_tools : : pod_to_hex ( block_blob_hash ) = = correct_blob_hash_202612 )
{
2014-09-05 22:10:47 +00:00
string_tools : : hex_to_pod ( existing_block_id_202612 , res ) ;
2014-09-05 22:06:08 +00:00
return true ;
}
2014-09-05 22:32:31 +00:00
bool hash_result = get_object_hash ( get_block_hashing_blob ( b ) , res ) ;
if ( hash_result )
{
// make sure that we aren't looking at a block with the 202612 block id but not the correct blobdata
if ( string_tools : : pod_to_hex ( res ) = = existing_block_id_202612 )
{
LOG_ERROR ( " Block with block id for 202612 but incorrect block blob hash found! " ) ;
res = null_hash ;
return false ;
}
}
return hash_result ;
2014-03-03 22:07:58 +00:00
}
//---------------------------------------------------------------
2017-03-22 18:01:09 +00:00
bool get_block_hash ( const block & b , crypto : : hash & res )
{
2017-03-25 09:18:53 +00:00
if ( b . is_hash_valid ( ) )
2017-03-22 18:01:09 +00:00
{
# ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
CHECK_AND_ASSERT_THROW_MES ( ! calculate_block_hash ( b , res ) | | b . hash = = res , " block hash cash integrity failure " ) ;
# endif
res = b . hash ;
+ + block_hashes_cached_count ;
return true ;
}
+ + block_hashes_calculated_count ;
bool ret = calculate_block_hash ( b , res ) ;
if ( ! ret )
return false ;
b . hash = res ;
2017-03-25 09:18:53 +00:00
b . set_hash_valid ( true ) ;
2017-03-22 18:01:09 +00:00
return true ;
}
//---------------------------------------------------------------
2014-03-03 22:07:58 +00:00
crypto : : hash get_block_hash ( const block & b )
{
crypto : : hash p = null_hash ;
get_block_hash ( b , p ) ;
return p ;
}
//---------------------------------------------------------------
bool get_block_longhash ( const block & b , crypto : : hash & res , uint64_t height )
{
2014-09-06 02:04:11 +00:00
// block 202612 bug workaround
const std : : string longhash_202612 = " 84f64766475d51837ac9efbef1926486e58563c95a19fef4aec3254f03000000 " ;
if ( height = = 202612 )
{
string_tools : : hex_to_pod ( longhash_202612 , res ) ;
return true ;
}
2014-03-03 22:07:58 +00:00
blobdata bd = get_block_hashing_blob ( b ) ;
crypto : : cn_slow_hash ( bd . data ( ) , bd . size ( ) , res ) ;
return true ;
}
//---------------------------------------------------------------
std : : vector < uint64_t > relative_output_offsets_to_absolute ( const std : : vector < uint64_t > & off )
{
std : : vector < uint64_t > res = off ;
for ( size_t i = 1 ; i < res . size ( ) ; i + + )
res [ i ] + = res [ i - 1 ] ;
return res ;
}
//---------------------------------------------------------------
std : : vector < uint64_t > absolute_output_offsets_to_relative ( const std : : vector < uint64_t > & off )
{
std : : vector < uint64_t > res = off ;
if ( ! off . size ( ) )
return res ;
std : : sort ( res . begin ( ) , res . end ( ) ) ; //just to be sure, actually it is already should be sorted
for ( size_t i = res . size ( ) - 1 ; i ! = 0 ; i - - )
res [ i ] - = res [ i - 1 ] ;
return res ;
}
//---------------------------------------------------------------
crypto : : hash get_block_longhash ( const block & b , uint64_t height )
{
crypto : : hash p = null_hash ;
get_block_longhash ( b , p , height ) ;
return p ;
}
//---------------------------------------------------------------
bool parse_and_validate_block_from_blob ( const blobdata & b_blob , block & b )
{
std : : stringstream ss ;
ss < < b_blob ;
binary_archive < false > ba ( ss ) ;
bool r = : : serialization : : serialize ( ba , b ) ;
CHECK_AND_ASSERT_MES ( r , false , " Failed to parse block from blob " ) ;
2017-03-25 09:18:53 +00:00
b . invalidate_hashes ( ) ;
b . miner_tx . invalidate_hashes ( ) ;
2014-03-03 22:07:58 +00:00
return true ;
}
//---------------------------------------------------------------
blobdata block_to_blob ( const block & b )
{
return t_serializable_object_to_blob ( b ) ;
}
//---------------------------------------------------------------
bool block_to_blob ( const block & b , blobdata & b_blob )
{
return t_serializable_object_to_blob ( b , b_blob ) ;
}
//---------------------------------------------------------------
blobdata tx_to_blob ( const transaction & tx )
{
return t_serializable_object_to_blob ( tx ) ;
}
//---------------------------------------------------------------
bool tx_to_blob ( const transaction & tx , blobdata & b_blob )
{
return t_serializable_object_to_blob ( tx , b_blob ) ;
}
//---------------------------------------------------------------
void get_tx_tree_hash ( const std : : vector < crypto : : hash > & tx_hashes , crypto : : hash & h )
{
tree_hash ( tx_hashes . data ( ) , tx_hashes . size ( ) , h ) ;
}
//---------------------------------------------------------------
crypto : : hash get_tx_tree_hash ( const std : : vector < crypto : : hash > & tx_hashes )
{
crypto : : hash h = null_hash ;
get_tx_tree_hash ( tx_hashes , h ) ;
return h ;
}
//---------------------------------------------------------------
crypto : : hash get_tx_tree_hash ( const block & b )
{
std : : vector < crypto : : hash > txs_ids ;
crypto : : hash h = null_hash ;
size_t bl_sz = 0 ;
get_transaction_hash ( b . miner_tx , h , bl_sz ) ;
txs_ids . push_back ( h ) ;
2017-01-22 20:38:10 +00:00
for ( auto & th : b . tx_hashes )
2014-03-03 22:07:58 +00:00
txs_ids . push_back ( th ) ;
return get_tx_tree_hash ( txs_ids ) ;
}
//---------------------------------------------------------------
2015-10-06 14:58:09 +00:00
bool is_valid_decomposed_amount ( uint64_t amount )
{
const uint64_t * begin = valid_decomposed_outputs ;
const uint64_t * end = valid_decomposed_outputs + sizeof ( valid_decomposed_outputs ) / sizeof ( valid_decomposed_outputs [ 0 ] ) ;
return std : : binary_search ( begin , end , amount ) ;
}
//---------------------------------------------------------------
2017-03-22 18:01:09 +00:00
void get_hash_stats ( uint64_t & tx_hashes_calculated , uint64_t & tx_hashes_cached , uint64_t & block_hashes_calculated , uint64_t & block_hashes_cached )
{
tx_hashes_calculated = tx_hashes_calculated_count ;
tx_hashes_cached = tx_hashes_cached_count ;
block_hashes_calculated = block_hashes_calculated_count ;
block_hashes_cached = block_hashes_cached_count ;
}
2017-08-06 15:51:40 +00:00
//---------------------------------------------------------------
2017-11-25 14:50:15 +00:00
crypto : : secret_key encrypt_key ( crypto : : secret_key key , const epee : : wipeable_string & passphrase )
2017-08-06 15:51:40 +00:00
{
crypto : : hash hash ;
crypto : : cn_slow_hash ( passphrase . data ( ) , passphrase . size ( ) , hash ) ;
sc_add ( ( unsigned char * ) key . data , ( const unsigned char * ) key . data , ( const unsigned char * ) hash . data ) ;
return key ;
}
//---------------------------------------------------------------
2017-11-25 14:50:15 +00:00
crypto : : secret_key decrypt_key ( crypto : : secret_key key , const epee : : wipeable_string & passphrase )
2017-08-06 15:51:40 +00:00
{
crypto : : hash hash ;
crypto : : cn_slow_hash ( passphrase . data ( ) , passphrase . size ( ) , hash ) ;
sc_sub ( ( unsigned char * ) key . data , ( const unsigned char * ) key . data , ( const unsigned char * ) hash . data ) ;
return key ;
}
2014-03-03 22:07:58 +00:00
}