rct Namespace Reference

Classes
struct	MultiexpData
struct	key
struct	ctkey
struct	multisig_kLRki
struct	multisig_out
struct	ecdhTuple
struct	boroSig
struct	geDsmp
struct	mgSig
struct	rangeSig
struct	Bulletproof
struct	RCTConfig
struct	rctSigBase
struct	rctSigPrunable
struct	rctSig

Typedefs
typedef unsigned char *	Bytes
typedef std::vector< key >	keyV
typedef std::vector< keyV >	keyM
typedef std::vector< ctkey >	ctkeyV
typedef std::vector< ctkeyV >	ctkeyM
typedef uint64_t	etn_amount
typedef unsigned int	bits[ATOMS]
typedef key	key64[64]

Enumerations
enum	{   RCTTypeNull = 0 , RCTTypeFull = 1 , RCTTypeSimple = 2 , RCTTypeBulletproof = 3 ,   RCTTypeBulletproof2 = 4 }
enum	RangeProofType { RangeProofBorromean , RangeProofBulletproof , RangeProofMultiOutputBulletproof , RangeProofPaddedBulletproof }

Functions
Bulletproof	bulletproof_PROVE (const rct::key &v, const rct::key &gamma)
Bulletproof	bulletproof_PROVE (uint64_t v, const rct::key &gamma)
Bulletproof	bulletproof_PROVE (const rct::keyV &v, const rct::keyV &gamma)
Bulletproof	bulletproof_PROVE (const std::vector< uint64_t > &v, const rct::keyV &gamma)
bool	bulletproof_VERIFY (const Bulletproof &proof)
bool	bulletproof_VERIFY (const std::vector< const Bulletproof * > &proofs)
bool	bulletproof_VERIFY (const std::vector< Bulletproof > &proofs)
rct::key	bos_coster_heap_conv (std::vector< MultiexpData > data)
rct::key	bos_coster_heap_conv_robust (std::vector< MultiexpData > data)
std::shared_ptr< straus_cached_data >	straus_init_cache (const std::vector< MultiexpData > &data, size_t N=0)
size_t	straus_get_cache_size (const std::shared_ptr< straus_cached_data > &cache)
rct::key	straus (const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
std::shared_ptr< pippenger_cached_data >	pippenger_init_cache (const std::vector< MultiexpData > &data, size_t start_offset=0, size_t N=0)
size_t	pippenger_get_cache_size (const std::shared_ptr< pippenger_cached_data > &cache)
size_t	get_pippenger_c (size_t N)
rct::key	pippenger (const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
keyM	keyMInit (size_t rows, size_t cols)
bool	toPointCheckOrder (ge_p3 *P, const unsigned char *data)
void	skGen (key &sk)
key	skGen ()
keyV	skvGen (size_t rows)
key	pkGen ()
void	skpkGen (key &sk, key &pk)
tuple< key, key >	skpkGen ()
void	genC (key &C, const key &a, etn_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (etn_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (const key &bH)
key	zeroCommit (etn_amount amount)
key	commit (etn_amount amount, const key &mask)
etn_amount	randEtnAmount (etn_amount upperlimit)
void	scalarmultBase (key &aG, const key &a)
key	scalarmultBase (const key &a)
void	scalarmultKey (key &aP, const key &P, const key &a)
key	scalarmultKey (const key &P, const key &a)
key	scalarmultH (const key &a)
key	scalarmult8 (const key &P)
bool	isInMainSubgroup (const key &A)
void	addKeys (key &AB, const key &A, const key &B)
rct::key	addKeys (const key &A, const key &B)
rct::key	addKeys (const keyV &A)
void	addKeys1 (key &aGB, const key &a, const key &B)
void	addKeys2 (key &aGbB, const key &a, const key &b, const key &B)
void	precomp (ge_dsmp rv, const key &B)
void	addKeys3 (key &aAbB, const key &a, const key &A, const key &b, const ge_dsmp B)
void	addKeys3 (key &aAbB, const key &a, const ge_dsmp A, const key &b, const ge_dsmp B)
void	subKeys (key &AB, const key &A, const key &B)
bool	equalKeys (const key &a, const key &b)
void	cn_fast_hash (key &hash, const void *data, const std::size_t l)
void	hash_to_scalar (key &hash, const void *data, const std::size_t l)
void	cn_fast_hash (key &hash, const key &in)
void	hash_to_scalar (key &hash, const key &in)
key	cn_fast_hash (const key &in)
key	hash_to_scalar (const key &in)
key	cn_fast_hash128 (const void *in)
key	hash_to_scalar128 (const void *in)
key	cn_fast_hash (const ctkeyV &PC)
key	hash_to_scalar (const ctkeyV &PC)
key	cn_fast_hash (const keyV &keys)
key	hash_to_scalar (const keyV &keys)
key	cn_fast_hash (const key64 keys)
key	hash_to_scalar (const key64 keys)
key	hashToPointSimple (const key &hh)
key	hashToPoint (const key &hh)
void	hashToPoint (key &pointk, const key &hh)
void	sumKeys (key &Csum, const keyV &Cis)
key	genCommitmentMask (const key &sk)
void	ecdhEncode (ecdhTuple &unmasked, const key &sharedSec, bool v2)
void	ecdhDecode (ecdhTuple &masked, const key &sharedSec, bool v2)
key	zero ()
void	zero (key &z)
key	identity ()
void	identity (key &Id)
key	curveOrder ()
void	curveOrder (key &l)
void	copy (key &AA, const key &A)
key	copy (const key &A)
bool	toPointCheckOrder (ge_p3 *P, const unsigned char *data)
void	cn_fast_hash (key &hash, const void *data, const size_t l)
void	hash_to_scalar (key &hash, const void *data, const size_t l)
void	sumKeys (key &Csum, const key &Cis)
void	ecdhEncode (ecdhTuple &unmasked, const key &sharedSec, bool v2)
void	ecdhDecode (ecdhTuple &masked, const key &sharedSec, bool v2)
Bulletproof	proveRangeBulletproof (keyV &C, keyV &masks, const std::vector< uint64_t > &amounts, epee::span< const key > sk, hw::device &hwdev)
bool	verBulletproof (const Bulletproof &proof)
bool	verBulletproof (const std::vector< const Bulletproof * > &proofs)
boroSig	genBorromean (const key64 x, const key64 P1, const key64 P2, const bits indices)
bool	verifyBorromean (const boroSig &bb, const ge_p3 P1[64], const ge_p3 P2[64])
bool	verifyBorromean (const boroSig &bb, const key64 P1, const key64 P2)
mgSig	MLSAG_Gen (const key &message, const keyM &pk, const keyV &xx, const multisig_kLRki *kLRki, key *mscout, const unsigned int index, size_t dsRows, hw::device &hwdev)
bool	MLSAG_Ver (const key &message, const keyM &pk, const mgSig &rv, size_t dsRows)
rangeSig	proveRange (key &C, key &mask, const etn_amount &amount)
bool	verRange (const key &C, const rangeSig &as)
key	get_pre_mlsag_hash (const rctSig &rv, hw::device &hwdev)
mgSig	proveRctMG (const key &message, const ctkeyM &pubs, const ctkeyV &inSk, const ctkeyV &outSk, const ctkeyV &outPk, const multisig_kLRki *kLRki, key *mscout, unsigned int index, const key &txnFeeKey, hw::device &hwdev)
mgSig	proveRctMGSimple (const key &message, const ctkeyV &pubs, const ctkey &inSk, const key &a, const key &Cout, const multisig_kLRki *kLRki, key *mscout, unsigned int index, hw::device &hwdev)
bool	verRctMG (const mgSig &mg, const ctkeyM &pubs, const ctkeyV &outPk, const key &txnFeeKey, const key &message)
bool	verRctMGSimple (const key &message, const mgSig &mg, const ctkeyV &pubs, const key &C)
void	getKeyFromBlockchain (ctkey &a, size_t reference_index)
tuple< ctkeyM, etn_amount >	populateFromBlockchain (ctkeyV inPk, int mixin)
etn_amount	populateFromBlockchainSimple (ctkeyV &mixRing, const ctkey &inPk, int mixin)
rctSig	genRct (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
rctSig	genRct (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< etn_amount > &amounts, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, const int mixin, const RCTConfig &rct_config, hw::device &hwdev)
rctSig	genRctSimple (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &inamounts, const vector< etn_amount > &outamounts, etn_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
rctSig	genRctSimple (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< etn_amount > &inamounts, const vector< etn_amount > &outamounts, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, etn_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev)
bool	verRct (const rctSig &rv, bool semantics)
bool	verRctSemanticsSimple (const std::vector< const rctSig * > &rvv)
bool	verRctSemanticsSimple (const rctSig &rv)
bool	verRctNonSemanticsSimple (const rctSig &rv)
etn_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
etn_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
etn_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
etn_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
bool	signMultisig (rctSig &rv, const std::vector< unsigned int > &indices, const keyV &k, const multisig_out &msout, const key &secret_key)
mgSig	proveRctMG (const ctkeyM &pubs, const ctkeyV &inSk, const keyV &outMasks, const ctkeyV &outPk, const multisig_kLRki *kLRki, key *mscout, unsigned int index, const key &txnFee, const key &message, hw::device &hwdev)
bool	verRct (const rctSig &rv, bool semantics)
void	dp (key a)
void	dp (bool a)
void	dp (const char *a, int l)
void	dp (keyV a)
void	dp (keyM a)
void	dp (etn_amount vali)
void	dp (bits amountb)
void	dp (const char *st)
void	d2h (key &amounth, const etn_amount in)
key	d2h (const etn_amount in)
void	d2b (bits amountb, etn_amount val)
etn_amount	h2d (const key &test)
void	h2b (bits amountb2, const key &test)
void	b2h (key &amountdh, const bits amountb2)
etn_amount	b2d (bits amountb)
bool	is_rct_simple (int type)
bool	is_rct_bulletproof (int type)
bool	is_rct_borromean (int type)
size_t	n_bulletproof_amounts (const Bulletproof &proof)
size_t	n_bulletproof_amounts (const std::vector< Bulletproof > &proofs)
size_t	n_bulletproof_max_amounts (const Bulletproof &proof)
size_t	n_bulletproof_max_amounts (const std::vector< Bulletproof > &proofs)
void	dp (bool a)
std::ostream &	operator<< (std::ostream &o, const rct::key &v)

Typedef Documentation

bits

typedef unsigned int rct::bits[ATOMS]

Definition at line 136 of file rctTypes.h.

Bytes

typedef unsigned char* rct::Bytes

Definition at line 72 of file rctTypes.h.

ctkeyM

typedef std::vector<ctkeyV> rct::ctkeyM

Definition at line 101 of file rctTypes.h.

ctkeyV

typedef std::vector<ctkey> rct::ctkeyV

Definition at line 100 of file rctTypes.h.

etn_amount

typedef uint64_t rct::etn_amount

Definition at line 135 of file rctTypes.h.

key64

typedef key rct::key64[64]

Definition at line 137 of file rctTypes.h.

keyM

typedef std::vector<keyV> rct::keyM

Definition at line 89 of file rctTypes.h.

keyV

typedef std::vector<key> rct::keyV

Definition at line 88 of file rctTypes.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RCTTypeNull
RCTTypeFull
RCTTypeSimple
RCTTypeBulletproof
RCTTypeBulletproof2

Definition at line 228 of file rctTypes.h.

         {
      RCTTypeNull = 0,
      RCTTypeFull = 1,
      RCTTypeSimple = 2,
      RCTTypeBulletproof = 3,
      RCTTypeBulletproof2 = 4,
    };

RangeProofType

enum rct::RangeProofType

Enumerator
RangeProofBorromean
RangeProofBulletproof
RangeProofMultiOutputBulletproof
RangeProofPaddedBulletproof

Definition at line 235 of file rctTypes.h.

{ RangeProofBorromean, RangeProofBulletproof, RangeProofMultiOutputBulletproof, RangeProofPaddedBulletproof };

Function Documentation

addKeys() [1/3]

rct::key rct::addKeys	(	const key &	A,
		const key &	B )

Definition at line 432 of file rctOps.cpp.

                                               {
      key k;
      addKeys(k, A, B);
      return k;
    }

Here is the call graph for this function:

addKeys() [2/3]

rct::key rct::addKeys

(

const keyV &

A

)

Definition at line 438 of file rctOps.cpp.

                                  {
      if (A.empty())
        return rct::identity();
      ge_p3 p3, tmp;
      CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&p3, A[0].bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
      for (size_t i = 1; i < A.size(); ++i)
      {
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&tmp, A[i].bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_cached p2;
        ge_p3_to_cached(&p2, &tmp);
        ge_p1p1 p1;
        ge_add(&p1, &p3, &p2);
        ge_p1p1_to_p3(&p3, &p1);
      }
      rct::key res;
      ge_p3_tobytes(res.bytes, &p3);
      return res;
    }

Here is the call graph for this function:

addKeys() [3/3]

void rct::addKeys	(	key &	AB,
		const key &	A,
		const key &	B )

Definition at line 420 of file rctOps.cpp.

                                                      {
        ge_p3 B2, A2;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, B.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A2, A.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_cached tmp2;
        ge_p3_to_cached(&tmp2, &B2);
        ge_p1p1 tmp3;
        ge_add(&tmp3, &A2, &tmp2);
        ge_p1p1_to_p3(&A2, &tmp3);
        ge_p3_tobytes(AB.bytes, &A2);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

addKeys1()

void rct::addKeys1	(	key &	aGB,
		const key &	a,
		const key &	B )

Definition at line 459 of file rctOps.cpp.

                                                         {
        key aG = scalarmultBase(a);
        addKeys(aGB, aG, B);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

addKeys2()

void rct::addKeys2	(	key &	aGbB,
		const key &	a,
		const key &	b,
		const key &	B )

Definition at line 466 of file rctOps.cpp.

                                                                        {
        ge_p2 rv;
        ge_p3 B2;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, B.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_double_scalarmult_base_vartime(&rv, b.bytes, &B2, a.bytes);
        ge_tobytes(aGbB.bytes, &rv);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

addKeys3() [1/2]

void rct::addKeys3	(	key &	aAbB,
		const key &	a,
		const ge_dsmp	A,
		const key &	b,
		const ge_dsmp	B )

Definition at line 496 of file rctOps.cpp.

                                                                                           {
        ge_p2 rv;
        ge_double_scalarmult_precomp_vartime2(&rv, a.bytes, A, b.bytes, B);
        ge_tobytes(aAbB.bytes, &rv);
    }

Here is the call graph for this function:

addKeys3() [2/2]

void rct::addKeys3	(	key &	aAbB,
		const key &	a,
		const key &	A,
		const key &	b,
		const ge_dsmp	B )

Definition at line 485 of file rctOps.cpp.

                                                                                        {
        ge_p2 rv;
        ge_p3 A2;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A2, A.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_double_scalarmult_precomp_vartime(&rv, a.bytes, &A2, b.bytes, B);
        ge_tobytes(aAbB.bytes, &rv);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

b2d()

etn_amount rct::b2d

(

bits

amountb

)

Definition at line 205 of file rctTypes.cpp.

                                 {
        etn_amount vali = 0;
        int j = 0;
        for (j = 63; j >= 0; j--) {
            vali = (etn_amount)(vali * 2 + amountb[j]);
        }
        return vali;
    }

Here is the caller graph for this function:

b2h()

void rct::b2h	(	key &	amountdh,
		const bits	amountb2 )

Definition at line 189 of file rctTypes.cpp.

                                                  {
        int byte, i, j;
        for (j = 0; j < 8; j++) {
            byte = 0;
            i = 8 * j;
            for (i = 7; i > -1; i--) {
                byte = byte * 2 + amountb2[8 * j + i];
            }
            amountdh[j] = (unsigned char)byte;
        }
        for (j = 8; j < 32; j++) {
            amountdh[j] = (unsigned char)(0x00);
        }
    }

Here is the caller graph for this function:

bos_coster_heap_conv()

rct::key rct::bos_coster_heap_conv

(

std::vector< MultiexpData >

data

)

bos_coster_heap_conv_robust()

rct::key rct::bos_coster_heap_conv_robust

(

std::vector< MultiexpData >

data

)

bulletproof_PROVE() [1/4]

Bulletproof rct::bulletproof_PROVE	(	const rct::key &	v,
		const rct::key &	gamma )

Here is the caller graph for this function:

bulletproof_PROVE() [2/4]

Bulletproof rct::bulletproof_PROVE	(	const rct::keyV &	v,
		const rct::keyV &	gamma )

bulletproof_PROVE() [3/4]

Bulletproof rct::bulletproof_PROVE	(	const std::vector< uint64_t > &	v,
		const rct::keyV &	gamma )

bulletproof_PROVE() [4/4]

Bulletproof rct::bulletproof_PROVE	(	uint64_t	v,
		const rct::key &	gamma )

bulletproof_VERIFY() [1/3]

bool rct::bulletproof_VERIFY

(

const Bulletproof &

proof

)

Here is the caller graph for this function:

bulletproof_VERIFY() [2/3]

bool rct::bulletproof_VERIFY

(

const std::vector< Bulletproof > &

proofs

)

bulletproof_VERIFY() [3/3]

bool rct::bulletproof_VERIFY

(

const std::vector< const Bulletproof * > &

proofs

)

cn_fast_hash() [1/7]

key rct::cn_fast_hash

(

const ctkeyV &

PC

)

Definition at line 580 of file rctOps.cpp.

                                       {
        if (PC.empty()) return rct::hash2rct(crypto::cn_fast_hash("", 0));
        key rv;
        cn_fast_hash(rv, &PC[0], 64*PC.size());
        return rv;
    }

Here is the call graph for this function:

cn_fast_hash() [2/7]

key rct::cn_fast_hash

(

const key &

in

)

Definition at line 552 of file rctOps.cpp.

                                     {
        key hash;
        keccak((const uint8_t *)in.bytes, 32, hash.bytes, 32);
        return hash;
    }

Here is the call graph for this function:

cn_fast_hash() [3/7]

key rct::cn_fast_hash

(

const key64

keys

)

Definition at line 611 of file rctOps.cpp.

                                      {
      key rv;
      cn_fast_hash(rv, &keys[0], 64 * sizeof(keys[0]));
      //dp(rv);
      return rv;
   }

Here is the call graph for this function:

cn_fast_hash() [4/7]

key rct::cn_fast_hash

(

const keyV &

keys

)

Definition at line 597 of file rctOps.cpp.

                                      {
       if (keys.empty()) return rct::hash2rct(crypto::cn_fast_hash("", 0));
       key rv;
       cn_fast_hash(rv, &keys[0], keys.size() * sizeof(keys[0]));
       //dp(rv);
       return rv;
   }

Here is the call graph for this function:

cn_fast_hash() [5/7]

void rct::cn_fast_hash	(	key &	hash,
		const key &	in )

Definition at line 542 of file rctOps.cpp.

                                                  {
        keccak((const uint8_t *)in.bytes, 32, hash.bytes, 32);
    }

Here is the call graph for this function:

cn_fast_hash() [6/7]

void rct::cn_fast_hash	(	key &	hash,
		const void *	data,
		const size_t	l )

cn_fast_hash() [7/7]

void rct::cn_fast_hash	(	key &	hash,
		const void *	data,
		const std::size_t	l )

Definition at line 532 of file rctOps.cpp.

                                                                       {
        keccak((const uint8_t *)data, l, hash.bytes, 32);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

cn_fast_hash128()

key rct::cn_fast_hash128

(

const void *

in

)

Definition at line 565 of file rctOps.cpp.

                                         {
        key hash;
        keccak((const uint8_t *)in, 128, hash.bytes, 32);
        return hash;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

commit()

key rct::commit	(	etn_amount	amount,
		const key &	mask )

Definition at line 336 of file rctOps.cpp.

                                                   {
        key c;
        genC(c, mask, amount);
        return c;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

copy() [1/2]

key rct::copy ( const key & A )

inline

Definition at line 80 of file rctOps.h.

{ key AA; memcpy(&AA, &A, 32); return AA; }

Here is the call graph for this function:

copy() [2/2]

void rct::copy ( key & AA, const key & A )

inline

Definition at line 79 of file rctOps.h.

{ memcpy(&AA, &A, 32); }

Here is the call graph for this function:

Here is the caller graph for this function:

ctskpkGen() [1/2]

std::tuple< ctkey, ctkey > rct::ctskpkGen

(

const key &

bH

)

Definition at line 314 of file rctOps.cpp.

                                                 {
        ctkey sk, pk;
        skpkGen(sk.dest, pk.dest);
        skpkGen(sk.mask, pk.mask);
        addKeys(pk.mask, pk.mask, bH);
        return make_tuple(sk, pk);
    }

Here is the call graph for this function:

ctskpkGen() [2/2]

std::tuple< ctkey, ctkey > rct::ctskpkGen

(

etn_amount

amount

)

Definition at line 302 of file rctOps.cpp.

                                                     {
        ctkey sk, pk;
        skpkGen(sk.dest, pk.dest);
        skpkGen(sk.mask, pk.mask);
        key am = d2h(amount);
        key bH = scalarmultH(am);
        addKeys(pk.mask, pk.mask, bH);
        return make_tuple(sk, pk);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

curveOrder() [1/2]

key rct::curveOrder ( )

inline

Definition at line 76 of file rctOps.h.

{ return L; }

Here is the caller graph for this function:

curveOrder() [2/2]

void rct::curveOrder ( key & l )

inline

Definition at line 77 of file rctOps.h.

{ l = L; }

d2b()

void rct::d2b	(	bits	amountb,
		etn_amount	val )

Definition at line 145 of file rctTypes.cpp.

                                            {
        int i = 0;
        while (val != 0) {
            amountb[i] = val & 1;
            i++;
            val >>= 1;
        }
        while (i < 64) {
            amountb[i] = 0;
            i++;
        }
    }

Here is the caller graph for this function:

d2h() [1/2]

key rct::d2h

(

const etn_amount

in

)

Definition at line 131 of file rctTypes.cpp.

                                 {
        key amounth;
        sc_0(amounth.bytes);
        etn_amount val = in;
        int i = 0;
        while (val != 0) {
            amounth[i] = (unsigned char)(val & 0xFF);
            i++;
            val /= (etn_amount)256;
        }
        return amounth;
    }

Here is the call graph for this function:

d2h() [2/2]

void rct::d2h	(	key &	amounth,
		const etn_amount	in )

Definition at line 119 of file rctTypes.cpp.

                                                 {
        sc_0(amounth.bytes);
        etn_amount val = in;
        int i = 0;
        while (val != 0) {
            amounth[i] = (unsigned char)(val & 0xFF);
            i++;
            val /= (etn_amount)256;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRct() [1/2]

etn_amount rct::decodeRct	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		hw::device &	hwdev )

Definition at line 1175 of file rctSigs.cpp.

                                                                                             {
      key mask;
      return decodeRct(rv, sk, i, mask, hwdev);
    }

Here is the call graph for this function:

decodeRct() [2/2]

etn_amount rct::decodeRct	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		key &	mask,
		hw::device &	hwdev )

Definition at line 1150 of file rctSigs.cpp.

                                                                                                         {
        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "decodeRct called on non-full rctSig");
        CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
        CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
 
        //mask amount and mask
        ecdhTuple ecdh_info = rv.ecdhInfo[i];
        hwdev.ecdhDecode(ecdh_info, sk, rv.type == RCTTypeBulletproof2);
        mask = ecdh_info.mask;
        key amount = ecdh_info.amount;
        key C = rv.outPk[i].mask;
        DP("C");
        DP(C);
        key Ctmp;
        CHECK_AND_ASSERT_THROW_MES(sc_check(mask.bytes) == 0, "warning, bad ECDH mask");
        CHECK_AND_ASSERT_THROW_MES(sc_check(amount.bytes) == 0, "warning, bad ECDH amount");
        addKeys2(Ctmp, mask, amount, H);
        DP("Ctmp");
        DP(Ctmp);
        if (equalKeys(C, Ctmp) == false) {
            CHECK_AND_ASSERT_THROW_MES(false, "warning, amount decoded incorrectly, will be unable to spend");
        }
        return h2d(amount);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRctSimple() [1/2]

etn_amount rct::decodeRctSimple	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		hw::device &	hwdev )

Definition at line 1205 of file rctSigs.cpp.

                                                                                                   {
      key mask;
      return decodeRctSimple(rv, sk, i, mask, hwdev);
    }

Here is the call graph for this function:

decodeRctSimple() [2/2]

etn_amount rct::decodeRctSimple	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		key &	mask,
		hw::device &	hwdev )

Definition at line 1180 of file rctSigs.cpp.

                                                                                                              {
        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2, false, "decodeRct called on non simple rctSig");
        CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
        CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
 
        //mask amount and mask
        ecdhTuple ecdh_info = rv.ecdhInfo[i];
        hwdev.ecdhDecode(ecdh_info, sk, rv.type == RCTTypeBulletproof2);
        mask = ecdh_info.mask;
        key amount = ecdh_info.amount;
        key C = rv.outPk[i].mask;
        DP("C");
        DP(C);
        key Ctmp;
        CHECK_AND_ASSERT_THROW_MES(sc_check(mask.bytes) == 0, "warning, bad ECDH mask");
        CHECK_AND_ASSERT_THROW_MES(sc_check(amount.bytes) == 0, "warning, bad ECDH amount");
        addKeys2(Ctmp, mask, amount, H);
        DP("Ctmp");
        DP(Ctmp);
        if (equalKeys(C, Ctmp) == false) {
            CHECK_AND_ASSERT_THROW_MES(false, "warning, amount decoded incorrectly, will be unable to spend");
        }
        return h2d(amount);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

dp() [1/9]

void rct::dp

(

bits

amountb

)

Definition at line 104 of file rctTypes.cpp.

                          {
        for (int i = 0; i < 64; i++) {
            printf("%d", amountb[i]);
        }
        printf("\n");
 
    }

dp() [2/9]

void rct::dp

(

bool

a

)

Definition at line 56 of file rctTypes.cpp.

                    {
        printf(" ... %s ... ", a ? "true" : "false");
        printf("\n");
    }

dp() [3/9]

void rct::dp

(

bool

a

)

Here is the call graph for this function:

dp() [4/9]

void rct::dp	(	const char *	a,
		int	l )

Definition at line 61 of file rctTypes.cpp.

                                   {
        int j = 0;
        printf("\"");
        for (j = 0; j < l; j++) {
            printf("%02x", (unsigned char)a[j]);
        }
        printf("\"");
        printf("\n");
    }

dp() [5/9]

void rct::dp

(

const char *

st

)

Definition at line 112 of file rctTypes.cpp.

                             {
        printf("%s\n", st);
    }

dp() [6/9]

void rct::dp

(

etn_amount

vali

)

Definition at line 94 of file rctTypes.cpp.

                             {
        printf("x: ");
        std::cout << vali;
        printf("\n\n");
    }

dp() [7/9]

void rct::dp

(

key

a

)

Definition at line 46 of file rctTypes.cpp.

                   {
        int j = 0;
        printf("\"");
        for (j = 0; j < 32; j++) {
            printf("%02x", (unsigned char)a.bytes[j]);
        }
        printf("\"");
        printf("\n");
    }

Here is the caller graph for this function:

dp() [8/9]

void rct::dp

(

keyM

a

)

Definition at line 82 of file rctTypes.cpp.

                    {
        size_t j = 0;
        printf("[");
        for (j = 0; j < a.size(); j++) {
            dp(a[j]);
            if (j < a.size() - 1) {
                printf(",");
            }
        }
        printf("]");
        printf("\n");
    }

Here is the call graph for this function:

dp() [9/9]

void rct::dp

(

keyV

a

)

Definition at line 70 of file rctTypes.cpp.

                    {
        size_t j = 0;
        printf("[");
        for (j = 0; j < a.size(); j++) {
            dp(a[j]);
            if (j < a.size() - 1) {
                printf(",");
            }
        }
        printf("]");
        printf("\n");
    }

Here is the call graph for this function:

ecdhDecode() [1/2]

void rct::ecdhDecode	(	ecdhTuple &	masked,
		const key &	sharedSec,
		bool	v2 )

Definition at line 712 of file rctOps.cpp.

                                                                        {
        //decode
        if (v2)
        {
          masked.mask = genCommitmentMask(sharedSec);
          xor8(masked.amount, ecdhHash(sharedSec));
        }
        else
        {
          key sharedSec1 = hash_to_scalar(sharedSec);
          key sharedSec2 = hash_to_scalar(sharedSec1);
          sc_sub(masked.mask.bytes, masked.mask.bytes, sharedSec1.bytes);
          sc_sub(masked.amount.bytes, masked.amount.bytes, sharedSec2.bytes);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ecdhDecode() [2/2]

void rct::ecdhDecode	(	ecdhTuple &	masked,
		const key &	sharedSec,
		bool	v2 )

ecdhEncode() [1/2]

void rct::ecdhEncode	(	ecdhTuple &	unmasked,
		const key &	sharedSec,
		bool	v2 )

Definition at line 697 of file rctOps.cpp.

                                                                          {
        //encode
        if (v2)
        {
          unmasked.mask = zero();
          xor8(unmasked.amount, ecdhHash(sharedSec));
        }
        else
        {
          key sharedSec1 = hash_to_scalar(sharedSec);
          key sharedSec2 = hash_to_scalar(sharedSec1);
          sc_add(unmasked.mask.bytes, unmasked.mask.bytes, sharedSec1.bytes);
          sc_add(unmasked.amount.bytes, unmasked.amount.bytes, sharedSec2.bytes);
        }
    }

Here is the call graph for this function:

ecdhEncode() [2/2]

void rct::ecdhEncode	(	ecdhTuple &	unmasked,
		const key &	sharedSec,
		bool	v2 )

equalKeys()

bool rct::equalKeys	(	const key &	a,
		const key &	b )

Definition at line 519 of file rctOps.cpp.

                                                 {
        bool rv = true;
        for (int i = 0; i < 32; ++i) {
          if (a.bytes[i] != b.bytes[i]) {
            rv = false;
          }
        }
        return rv;
    }

Here is the caller graph for this function:

genBorromean()

boroSig rct::genBorromean	(	const key64	x,
		const key64	P1,
		const key64	P2,
		const bits	indices )

Definition at line 109 of file rctSigs.cpp.

                                                                                            {
        key64 L[2], alpha;
        key c;
        int naught = 0, prime = 0, ii = 0, jj=0;
        boroSig bb;
        for (ii = 0 ; ii < 64 ; ii++) {
            naught = indices[ii]; prime = (indices[ii] + 1) % 2;
            skGen(alpha[ii]);
            scalarmultBase(L[naught][ii], alpha[ii]);
            if (naught == 0) {
                skGen(bb.s1[ii]);
                c = hash_to_scalar(L[naught][ii]);
                addKeys2(L[prime][ii], bb.s1[ii], c, P2[ii]);
            }
        }
        bb.ee = hash_to_scalar(L[1]); //or L[1]..
        key LL, cc;
        for (jj = 0 ; jj < 64 ; jj++) {
            if (!indices[jj]) {
                sc_mulsub(bb.s0[jj].bytes, x[jj].bytes, bb.ee.bytes, alpha[jj].bytes);
            } else {
                skGen(bb.s0[jj]);
                addKeys2(LL, bb.s0[jj], bb.ee, P1[jj]); //different L0
                cc = hash_to_scalar(LL);
                sc_mulsub(bb.s1[jj].bytes, x[jj].bytes, cc.bytes, alpha[jj].bytes);
            }
        }
        return bb;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

genC()

void rct::genC	(	key &	C,
		const key &	a,
		etn_amount	amount )

Definition at line 297 of file rctOps.cpp.

                                                         {
        addKeys2(C, a, d2h(amount), rct::H);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

genCommitmentMask()

key rct::genCommitmentMask

(

const key &

sk

)

Definition at line 687 of file rctOps.cpp.

    {
        char data[15 + sizeof(key)];
        memcpy(data, "commitment_mask", 15);
        memcpy(data + 15, &sk, sizeof(sk));
        key scalar;
        hash_to_scalar(scalar, data, sizeof(data));
        return scalar;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

genRct() [1/2]

rctSig rct::genRct	(	const key &	message,
		const ctkeyV &	inSk,
		const ctkeyV &	inPk,
		const keyV &	destinations,
		const vector< etn_amount > &	amounts,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		const int	mixin,
		const RCTConfig &	rct_config,
		hw::device &	hwdev )

Definition at line 742 of file rctSigs.cpp.

                                                                                                                                                                                                                                                                                          {
        unsigned int index;
        ctkeyM mixRing;
        ctkeyV outSk;
        tie(mixRing, index) = populateFromBlockchain(inPk, mixin);
        return genRct(message, inSk, destinations, amounts, mixRing, amount_keys, kLRki, msout, index, outSk, rct_config, hwdev);
    }

Here is the call graph for this function:

genRct() [2/2]

rctSig rct::genRct	(	const key &	message,
		const ctkeyV &	inSk,
		const keyV &	destinations,
		const vector< etn_amount > &	amounts,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		unsigned int	index,
		ctkeyV &	outSk,
		const RCTConfig &	rct_config,
		hw::device &	hwdev )

Definition at line 690 of file rctSigs.cpp.

                                                                                                                                                                                                                                                                                                             {
        CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations");
        CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
        CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing");
        for (size_t n = 0; n < mixRing.size(); ++n) {
          CHECK_AND_ASSERT_THROW_MES(mixRing[n].size() == inSk.size(), "Bad mixRing size");
        }
        CHECK_AND_ASSERT_THROW_MES((kLRki && msout) || (!kLRki && !msout), "Only one of kLRki/msout is present");
        CHECK_AND_ASSERT_THROW_MES(inSk.size() < 2, "genRct is not suitable for 2+ rings");
 
        rctSig rv;
        rv.type = RCTTypeFull;
        rv.message = message;
        rv.outPk.resize(destinations.size());
        rv.p.rangeSigs.resize(destinations.size());
        rv.ecdhInfo.resize(destinations.size());
 
        size_t i = 0;
        keyV masks(destinations.size()); //sk mask..
        outSk.resize(destinations.size());
        for (i = 0; i < destinations.size(); i++) {
            //add destination to sig
            rv.outPk[i].dest = copy(destinations[i]);
            //compute range proof
            rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, amounts[i]);
            #ifdef DBG
            CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
            #endif
            //mask amount and mask
            rv.ecdhInfo[i].mask = copy(outSk[i].mask);
            rv.ecdhInfo[i].amount = d2h(amounts[i]);
            hwdev.ecdhEncode(rv.ecdhInfo[i], amount_keys[i], rv.type == RCTTypeBulletproof2);
        }
 
        //set txn fee
        if (amounts.size() > destinations.size())
        {
          rv.txnFee = amounts[destinations.size()];
        }
        else
        {
          rv.txnFee = 0;
        }
        key txnFeeKey = scalarmultH(d2h(rv.txnFee));
 
        rv.mixRing = mixRing;
        if (msout)
          msout->c.resize(1);
        rv.p.MGs.push_back(proveRctMG(get_pre_mlsag_hash(rv, hwdev), rv.mixRing, inSk, outSk, rv.outPk, kLRki, msout ? &msout->c[0] : NULL, index, txnFeeKey,hwdev));
        return rv;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

genRctSimple() [1/2]

rctSig rct::genRctSimple	(	const key &	message,
		const ctkeyV &	inSk,
		const ctkeyV &	inPk,
		const keyV &	destinations,
		const vector< etn_amount > &	inamounts,
		const vector< etn_amount > &	outamounts,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		etn_amount	txnFee,
		unsigned int	mixin,
		const RCTConfig &	rct_config,
		hw::device &	hwdev )

Definition at line 890 of file rctSigs.cpp.

                                                                                                                                                                                                                                                                                                                                                                       {
        std::vector<unsigned int> index;
        index.resize(inPk.size());
        ctkeyM mixRing;
        ctkeyV outSk;
        mixRing.resize(inPk.size());
        for (size_t i = 0; i < inPk.size(); ++i) {
          mixRing[i].resize(mixin+1);
          index[i] = populateFromBlockchainSimple(mixRing[i], inPk[i], mixin);
        }
        return genRctSimple(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, kLRki, msout, index, outSk, rct_config, hwdev);
    }

Here is the call graph for this function:

genRctSimple() [2/2]

rctSig rct::genRctSimple	(	const key &	message,
		const ctkeyV &	inSk,
		const keyV &	destinations,
		const vector< etn_amount > &	inamounts,
		const vector< etn_amount > &	outamounts,
		etn_amount	txnFee,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		const std::vector< unsigned int > &	index,
		ctkeyV &	outSk,
		const RCTConfig &	rct_config,
		hw::device &	hwdev )

Definition at line 752 of file rctSigs.cpp.

                                                                                                                                                                                                                                                                                                                                                                                                            {
        const bool bulletproof = rct_config.range_proof_type != RangeProofBorromean;
        CHECK_AND_ASSERT_THROW_MES(inamounts.size() > 0, "Empty inamounts");
        CHECK_AND_ASSERT_THROW_MES(inamounts.size() == inSk.size(), "Different number of inamounts/inSk");
        CHECK_AND_ASSERT_THROW_MES(outamounts.size() == destinations.size(), "Different number of amounts/destinations");
        CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
        CHECK_AND_ASSERT_THROW_MES(index.size() == inSk.size(), "Different number of index/inSk");
        CHECK_AND_ASSERT_THROW_MES(mixRing.size() == inSk.size(), "Different number of mixRing/inSk");
        for (size_t n = 0; n < mixRing.size(); ++n) {
          CHECK_AND_ASSERT_THROW_MES(index[n] < mixRing[n].size(), "Bad index into mixRing");
        }
        CHECK_AND_ASSERT_THROW_MES((kLRki && msout) || (!kLRki && !msout), "Only one of kLRki/msout is present");
        if (kLRki && msout) {
          CHECK_AND_ASSERT_THROW_MES(kLRki->size() == inamounts.size(), "Mismatched kLRki/inamounts sizes");
        }
 
        rctSig rv;
        rv.type = bulletproof ? (rct_config.bp_version == 0 || rct_config.bp_version >= 2 ? RCTTypeBulletproof2 : RCTTypeBulletproof) : RCTTypeSimple;
        rv.message = message;
        rv.outPk.resize(destinations.size());
        if (!bulletproof)
          rv.p.rangeSigs.resize(destinations.size());
        rv.ecdhInfo.resize(destinations.size());
 
        size_t i;
        keyV masks(destinations.size()); //sk mask..
        outSk.resize(destinations.size());
        for (i = 0; i < destinations.size(); i++) {
 
            //add destination to sig
            rv.outPk[i].dest = copy(destinations[i]);
            //compute range proof
            if (!bulletproof)
              rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, outamounts[i]);
            #ifdef DBG
            if (!bulletproof)
                CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
            #endif
        }
 
        rv.p.bulletproofs.clear();
        if (bulletproof)
        {
            size_t n_amounts = outamounts.size();
            size_t amounts_proved = 0;
            if (rct_config.range_proof_type == RangeProofPaddedBulletproof)
            {
                rct::keyV C, masks;
                if (hwdev.get_mode() == hw::device::TRANSACTION_CREATE_FAKE)
                {
                    // use a fake bulletproof for speed
                    rv.p.bulletproofs.push_back(make_dummy_bulletproof(outamounts, C, masks));
                }
                else
                {
                    const epee::span<const key> keys{&amount_keys[0], amount_keys.size()};
                    rv.p.bulletproofs.push_back(proveRangeBulletproof(C, masks, outamounts, keys, hwdev));
                    #ifdef DBG
                    CHECK_AND_ASSERT_THROW_MES(verBulletproof(rv.p.bulletproofs.back()), "verBulletproof failed on newly created proof");
                    #endif
                }
                for (i = 0; i < outamounts.size(); ++i)
                {
                    rv.outPk[i].mask = rct::scalarmult8(C[i]);
                    outSk[i].mask = masks[i];
                }
            }
            else while (amounts_proved < n_amounts)
            {
                size_t batch_size = 1;
                if (rct_config.range_proof_type == RangeProofMultiOutputBulletproof)
                  while (batch_size * 2 + amounts_proved <= n_amounts && batch_size * 2 <= BULLETPROOF_MAX_OUTPUTS)
                    batch_size *= 2;
                rct::keyV C, masks;
                std::vector<uint64_t> batch_amounts(batch_size);
                for (i = 0; i < batch_size; ++i)
                  batch_amounts[i] = outamounts[i + amounts_proved];
                if (hwdev.get_mode() == hw::device::TRANSACTION_CREATE_FAKE)
                {
                    // use a fake bulletproof for speed
                    rv.p.bulletproofs.push_back(make_dummy_bulletproof(batch_amounts, C, masks));
                }
                else
                {
                    const epee::span<const key> keys{&amount_keys[amounts_proved], batch_size};
                    rv.p.bulletproofs.push_back(proveRangeBulletproof(C, masks, batch_amounts, keys, hwdev));
                #ifdef DBG
                    CHECK_AND_ASSERT_THROW_MES(verBulletproof(rv.p.bulletproofs.back()), "verBulletproof failed on newly created proof");
                #endif
                }
                for (i = 0; i < batch_size; ++i)
                {
                  rv.outPk[i + amounts_proved].mask = rct::scalarmult8(C[i]);
                  outSk[i + amounts_proved].mask = masks[i];
                }
                amounts_proved += batch_size;
            }
        }
 
        key sumout = zero();
        for (i = 0; i < outSk.size(); ++i)
        {
            sc_add(sumout.bytes, outSk[i].mask.bytes, sumout.bytes);
 
            //mask amount and mask
            rv.ecdhInfo[i].mask = copy(outSk[i].mask);
            rv.ecdhInfo[i].amount = d2h(outamounts[i]);
            hwdev.ecdhEncode(rv.ecdhInfo[i], amount_keys[i], rv.type == RCTTypeBulletproof2);
        }
            
        //set txn fee
        rv.txnFee = txnFee;
//        TODO: unused ??
//        key txnFeeKey = scalarmultH(d2h(rv.txnFee));
        rv.mixRing = mixRing;
        keyV &pseudoOuts = bulletproof ? rv.p.pseudoOuts : rv.pseudoOuts;
        pseudoOuts.resize(inamounts.size());
        rv.p.MGs.resize(inamounts.size());
        key sumpouts = zero(); //sum pseudoOut masks
        keyV a(inamounts.size());
        for (i = 0 ; i < inamounts.size() - 1; i++) {
            skGen(a[i]);
            sc_add(sumpouts.bytes, a[i].bytes, sumpouts.bytes);
            genC(pseudoOuts[i], a[i], inamounts[i]);
        }
        sc_sub(a[i].bytes, sumout.bytes, sumpouts.bytes);
        genC(pseudoOuts[i], a[i], inamounts[i]);
        DP(pseudoOuts[i]);
 
        key full_message = get_pre_mlsag_hash(rv,hwdev);
        if (msout)
          msout->c.resize(inamounts.size());
        for (i = 0 ; i < inamounts.size(); i++) {
            rv.p.MGs[i] = proveRctMGSimple(full_message, rv.mixRing[i], inSk[i], a[i], pseudoOuts[i], kLRki ? &(*kLRki)[i]: NULL, msout ? &msout->c[i] : NULL, index[i], hwdev);
        }
        return rv;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_pippenger_c()

size_t rct::get_pippenger_c

(

size_t

N

)

get_pre_mlsag_hash()

key rct::get_pre_mlsag_hash	(	const rctSig &	rv,
		hw::device &	hwdev )

Definition at line 403 of file rctSigs.cpp.

    {
      keyV hashes;
      hashes.reserve(3);
      hashes.push_back(rv.message);
      crypto::hash h;
 
      std::stringstream ss;
      binary_archive<true> ba(ss);
      CHECK_AND_ASSERT_THROW_MES(!rv.mixRing.empty(), "Empty mixRing");
      const size_t inputs = is_rct_simple(rv.type) ? rv.mixRing.size() : rv.mixRing[0].size();
      const size_t outputs = rv.ecdhInfo.size();
      key prehash;
      CHECK_AND_ASSERT_THROW_MES(const_cast<rctSig&>(rv).serialize_rctsig_base(ba, inputs, outputs),
          "Failed to serialize rctSigBase");
      cryptonote::get_blob_hash(ss.str(), h);
      hashes.push_back(hash2rct(h));
 
      keyV kv;
      if (rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2)
      {
        kv.reserve((6*2+9) * rv.p.bulletproofs.size());
        for (const auto &p: rv.p.bulletproofs)
        {
          // V are not hashed as they're expanded from outPk.mask
          // (and thus hashed as part of rctSigBase above)
          kv.push_back(p.A);
          kv.push_back(p.S);
          kv.push_back(p.T1);
          kv.push_back(p.T2);
          kv.push_back(p.taux);
          kv.push_back(p.mu);
          for (size_t n = 0; n < p.L.size(); ++n)
            kv.push_back(p.L[n]);
          for (size_t n = 0; n < p.R.size(); ++n)
            kv.push_back(p.R[n]);
          kv.push_back(p.a);
          kv.push_back(p.b);
          kv.push_back(p.t);
        }
      }
      else
      {
        kv.reserve((64*3+1) * rv.p.rangeSigs.size());
        for (const auto &r: rv.p.rangeSigs)
        {
          for (size_t n = 0; n < 64; ++n)
            kv.push_back(r.asig.s0[n]);
          for (size_t n = 0; n < 64; ++n)
            kv.push_back(r.asig.s1[n]);
          kv.push_back(r.asig.ee);
          for (size_t n = 0; n < 64; ++n)
            kv.push_back(r.Ci[n]);
        }
      }
      hashes.push_back(cn_fast_hash(kv));
      hwdev.mlsag_prehash(ss.str(), inputs, outputs, hashes, rv.outPk, prehash);
      return  prehash;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getKeyFromBlockchain()

void rct::getKeyFromBlockchain	(	ctkey &	a,
		size_t	reference_index )

Definition at line 635 of file rctSigs.cpp.

                                                                 {
        a.mask = pkGen();
        a.dest = pkGen();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

h2b()

void rct::h2b	(	bits	amountb2,
		const key &	test )

Definition at line 171 of file rctTypes.cpp.

                                              {
        int val = 0, i = 0, j = 0;
        for (j = 0; j < 8; j++) {
            val = (unsigned char)test.bytes[j];
            i = 8 * j;
            while (val != 0) {
                amountb2[i] = val & 1;
                i++;
                val >>= 1;
            }
            while (i < 8 * (j + 1)) {
                amountb2[i] = 0;
                i++;
            }
        }
    }

Here is the caller graph for this function:

h2d()

etn_amount rct::h2d

(

const key &

test

)

Definition at line 161 of file rctTypes.cpp.

                                     {
        etn_amount vali = 0;
        int j = 0;
        for (j = 7; j >= 0; j--) {
            vali = (etn_amount)(vali * 256 + (unsigned char)test.bytes[j]);
        }
        return vali;
    }

Here is the caller graph for this function:

hash_to_scalar() [1/7]

key rct::hash_to_scalar

(

const ctkeyV &

PC

)

Definition at line 587 of file rctOps.cpp.

                                         {
        key rv = cn_fast_hash(PC);
        sc_reduce32(rv.bytes);
        return rv;
    }

Here is the call graph for this function:

hash_to_scalar() [2/7]

key rct::hash_to_scalar

(

const key &

in

)

Definition at line 558 of file rctOps.cpp.

                                        {
        key hash = cn_fast_hash(in);
        sc_reduce32(hash.bytes);
        return hash;
     }

Here is the call graph for this function:

hash_to_scalar() [3/7]

key rct::hash_to_scalar

(

const key64

keys

)

Definition at line 618 of file rctOps.cpp.

                                        {
       key rv = cn_fast_hash(keys);
       sc_reduce32(rv.bytes);
       return rv;
   }

Here is the call graph for this function:

hash_to_scalar() [4/7]

key rct::hash_to_scalar

(

const keyV &

keys

)

Definition at line 605 of file rctOps.cpp.

                                        {
       key rv = cn_fast_hash(keys);
       sc_reduce32(rv.bytes);
       return rv;
   }

Here is the call graph for this function:

hash_to_scalar() [5/7]

void rct::hash_to_scalar	(	key &	hash,
		const key &	in )

Definition at line 546 of file rctOps.cpp.

                                                    {
        cn_fast_hash(hash, in);
        sc_reduce32(hash.bytes);
    }

Here is the call graph for this function:

hash_to_scalar() [6/7]

void rct::hash_to_scalar	(	key &	hash,
		const void *	data,
		const size_t	l )

hash_to_scalar() [7/7]

void rct::hash_to_scalar	(	key &	hash,
		const void *	data,
		const std::size_t	l )

Definition at line 536 of file rctOps.cpp.

                                                                         {
        cn_fast_hash(hash, data, l);
        sc_reduce32(hash.bytes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

hash_to_scalar128()

key rct::hash_to_scalar128

(

const void *

in

)

Definition at line 571 of file rctOps.cpp.

                                           {
        key hash = cn_fast_hash128(in);
        sc_reduce32(hash.bytes);
        return hash;
    }

Here is the call graph for this function:

hashToPoint() [1/2]

key rct::hashToPoint

(

const key &

hh

)

Definition at line 638 of file rctOps.cpp.

                                    {
        key pointk;
        ge_p2 point;
        ge_p1p1 point2;
        ge_p3 res;
        key h = cn_fast_hash(hh); 
        ge_fromfe_frombytes_vartime(&point, h.bytes);
        ge_mul8(&point2, &point);
        ge_p1p1_to_p3(&res, &point2);        
        ge_p3_tobytes(pointk.bytes, &res);
        return pointk;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

hashToPoint() [2/2]

void rct::hashToPoint	(	key &	pointk,
		const key &	hh )

Definition at line 651 of file rctOps.cpp.

                                                   {
        ge_p2 point;
        ge_p1p1 point2;
        ge_p3 res;
        key h = cn_fast_hash(hh); 
        ge_fromfe_frombytes_vartime(&point, h.bytes);
        ge_mul8(&point2, &point);
        ge_p1p1_to_p3(&res, &point2);        
        ge_p3_tobytes(pointk.bytes, &res);
    }    

Here is the call graph for this function:

hashToPointSimple()

key rct::hashToPointSimple

(

const key &

hh

)

Definition at line 624 of file rctOps.cpp.

                                          {
        key pointk;
        ge_p1p1 point2;
        ge_p2 point;
        ge_p3 res;
        key h = cn_fast_hash(hh); 
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&res, h.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_p3_to_p2(&point, &res);
        ge_mul8(&point2, &point);
        ge_p1p1_to_p3(&res, &point2);
        ge_p3_tobytes(pointk.bytes, &res);
        return pointk;
    }    

Here is the call graph for this function:

Here is the caller graph for this function:

identity() [1/2]

key rct::identity ( )

inline

Definition at line 73 of file rctOps.h.

{ return I; }

Here is the caller graph for this function:

identity() [2/2]

void rct::identity ( key & Id )

inline

Definition at line 74 of file rctOps.h.

{ memcpy(&Id, &I, 32); }

Here is the call graph for this function:

is_rct_borromean()

bool rct::is_rct_borromean

(

int

type

)

Definition at line 239 of file rctTypes.cpp.

    {
        switch (type)
        {
            case RCTTypeSimple:
            case RCTTypeFull:
                return true;
            default:
                return false;
        }
    }

Here is the caller graph for this function:

is_rct_bulletproof()

bool rct::is_rct_bulletproof

(

int

type

)

Definition at line 227 of file rctTypes.cpp.

    {
        switch (type)
        {
            case RCTTypeBulletproof:
            case RCTTypeBulletproof2:
                return true;
            default:
                return false;
        }
    }

Here is the caller graph for this function:

is_rct_simple()

bool rct::is_rct_simple

(

int

type

)

Definition at line 214 of file rctTypes.cpp.

    {
        switch (type)
        {
            case RCTTypeSimple:
            case RCTTypeBulletproof:
            case RCTTypeBulletproof2:
                return true;
            default:
                return false;
        }
    }

Here is the caller graph for this function:

isInMainSubgroup()

bool rct::isInMainSubgroup

(

const key &

A

)

Definition at line 412 of file rctOps.cpp.

                                         {
        ge_p3 p3;
        return toPointCheckOrder(&p3, A.bytes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

keyMInit()

keyM rct::keyMInit	(	size_t	rows,
		size_t	cols )

Definition at line 227 of file rctOps.cpp.

                                            {
        keyM rv(cols);
        size_t i = 0;
        for (i = 0 ; i < cols ; i++) {
            rv[i] = keyV(rows);
        }
        return rv;
    }

Here is the caller graph for this function:

MLSAG_Gen()

mgSig rct::MLSAG_Gen	(	const key &	message,
		const keyM &	pk,
		const keyV &	xx,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		const unsigned int	index,
		size_t	dsRows,
		hw::device &	hwdev )

Definition at line 174 of file rctSigs.cpp.

                                                                                                                                                                              {
        mgSig rv;
        size_t cols = pk.size();
        CHECK_AND_ASSERT_THROW_MES(cols >= 2, "Error! What is c if cols = 1!");
        CHECK_AND_ASSERT_THROW_MES(index < cols, "Index out of range");
        size_t rows = pk[0].size();
        CHECK_AND_ASSERT_THROW_MES(rows >= 1, "Empty pk");
        for (size_t i = 1; i < cols; ++i) {
          CHECK_AND_ASSERT_THROW_MES(pk[i].size() == rows, "pk is not rectangular");
        }
        CHECK_AND_ASSERT_THROW_MES(xx.size() == rows, "Bad xx size");
        CHECK_AND_ASSERT_THROW_MES(dsRows <= rows, "Bad dsRows size");
        CHECK_AND_ASSERT_THROW_MES((kLRki && mscout) || (!kLRki && !mscout), "Only one of kLRki/mscout is present");
        CHECK_AND_ASSERT_THROW_MES(!kLRki || dsRows == 1, "Multisig requires exactly 1 dsRows");
 
        size_t i = 0, j = 0, ii = 0;
        key c, c_old, L, R, Hi;
        sc_0(c_old.bytes);
        vector<geDsmp> Ip(dsRows);
        rv.II = keyV(dsRows);
        keyV alpha(rows);
        keyV aG(rows);
        rv.ss = keyM(cols, aG);
        keyV aHP(dsRows);
        keyV toHash(1 + 3 * dsRows + 2 * (rows - dsRows));
        toHash[0] = message;
        DP("here1");
        for (i = 0; i < dsRows; i++) {
            toHash[3 * i + 1] = pk[index][i];
            if (kLRki) {
              // multisig
              alpha[i] = kLRki->k;
              toHash[3 * i + 2] = kLRki->L;
              toHash[3 * i + 3] = kLRki->R;
              rv.II[i] = kLRki->ki;
            }
            else {
              Hi = hashToPoint(pk[index][i]);
              hwdev.mlsag_prepare(Hi, xx[i], alpha[i] , aG[i] , aHP[i] , rv.II[i]);
              toHash[3 * i + 2] = aG[i];
              toHash[3 * i + 3] = aHP[i];
            }
            precomp(Ip[i].k, rv.II[i]);
        }
        size_t ndsRows = 3 * dsRows; //non Double Spendable Rows (see identity chains paper)
        for (i = dsRows, ii = 0 ; i < rows ; i++, ii++) {
            skpkGen(alpha[i], aG[i]); //need to save alphas for later..
            toHash[ndsRows + 2 * ii + 1] = pk[index][i];
            toHash[ndsRows + 2 * ii + 2] = aG[i];
        }
 
        hwdev.mlsag_hash(toHash, c_old);
 
        
        i = (index + 1) % cols;
        if (i == 0) {
            copy(rv.cc, c_old);
        }
        while (i != index) {
 
            rv.ss[i] = skvGen(rows);            
            sc_0(c.bytes);
            for (j = 0; j < dsRows; j++) {
                addKeys2(L, rv.ss[i][j], c_old, pk[i][j]);
                hashToPoint(Hi, pk[i][j]);
                addKeys3(R, rv.ss[i][j], Hi, c_old, Ip[j].k);
                toHash[3 * j + 1] = pk[i][j];
                toHash[3 * j + 2] = L; 
                toHash[3 * j + 3] = R;
            }
            for (j = dsRows, ii = 0; j < rows; j++, ii++) {
                addKeys2(L, rv.ss[i][j], c_old, pk[i][j]);
                toHash[ndsRows + 2 * ii + 1] = pk[i][j];
                toHash[ndsRows + 2 * ii + 2] = L;
            }
            hwdev.mlsag_hash(toHash, c);
            copy(c_old, c);
            i = (i + 1) % cols;
            
            if (i == 0) { 
                copy(rv.cc, c_old);
            }   
        }
        hwdev.mlsag_sign(c, xx, alpha, rows, dsRows, rv.ss[index]);
        if (mscout)
          *mscout = c;
        return rv;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

MLSAG_Ver()

bool rct::MLSAG_Ver	(	const key &	message,
		const keyM &	pk,
		const mgSig &	rv,
		size_t	dsRows )

Definition at line 271 of file rctSigs.cpp.

                                                                                         {
 
        size_t cols = pk.size();
        CHECK_AND_ASSERT_MES(cols >= 2, false, "Error! What is c if cols = 1!");
        size_t rows = pk[0].size();
        CHECK_AND_ASSERT_MES(rows >= 1, false, "Empty pk");
        for (size_t i = 1; i < cols; ++i) {
          CHECK_AND_ASSERT_MES(pk[i].size() == rows, false, "pk is not rectangular");
        }
        CHECK_AND_ASSERT_MES(rv.II.size() == dsRows, false, "Bad II size");
        CHECK_AND_ASSERT_MES(rv.ss.size() == cols, false, "Bad rv.ss size");
        for (size_t i = 0; i < cols; ++i) {
          CHECK_AND_ASSERT_MES(rv.ss[i].size() == rows, false, "rv.ss is not rectangular");
        }
        CHECK_AND_ASSERT_MES(dsRows <= rows, false, "Bad dsRows value");
 
        for (size_t i = 0; i < rv.ss.size(); ++i)
          for (size_t j = 0; j < rv.ss[i].size(); ++j)
            CHECK_AND_ASSERT_MES(sc_check(rv.ss[i][j].bytes) == 0, false, "Bad ss slot");
        CHECK_AND_ASSERT_MES(sc_check(rv.cc.bytes) == 0, false, "Bad cc");
 
        size_t i = 0, j = 0, ii = 0;
        key c,  L, R, Hi;
        key c_old = copy(rv.cc);
        vector<geDsmp> Ip(dsRows);
        for (i = 0 ; i < dsRows ; i++) {
            precomp(Ip[i].k, rv.II[i]);
        }
        size_t ndsRows = 3 * dsRows; //non Double Spendable Rows (see identity chains paper
        keyV toHash(1 + 3 * dsRows + 2 * (rows - dsRows));
        toHash[0] = message;
        i = 0;
        while (i < cols) {
            sc_0(c.bytes);
            for (j = 0; j < dsRows; j++) {
                addKeys2(L, rv.ss[i][j], c_old, pk[i][j]);
                hashToPoint(Hi, pk[i][j]);
                CHECK_AND_ASSERT_MES(!(Hi == rct::identity()), false, "Data hashed to point at infinity");
                addKeys3(R, rv.ss[i][j], Hi, c_old, Ip[j].k);
                toHash[3 * j + 1] = pk[i][j];
                toHash[3 * j + 2] = L; 
                toHash[3 * j + 3] = R;
            }
            for (j = dsRows, ii = 0 ; j < rows ; j++, ii++) {
                addKeys2(L, rv.ss[i][j], c_old, pk[i][j]);
                toHash[ndsRows + 2 * ii + 1] = pk[i][j];
                toHash[ndsRows + 2 * ii + 2] = L;
            }
            c = hash_to_scalar(toHash);
            copy(c_old, c);
            i = (i + 1);
        }
        sc_sub(c.bytes, c_old.bytes, rv.cc.bytes);
        return sc_isnonzero(c.bytes) == 0;  
    }

Here is the call graph for this function:

Here is the caller graph for this function:

n_bulletproof_amounts() [1/2]

size_t rct::n_bulletproof_amounts

(

const Bulletproof &

proof

)

Definition at line 251 of file rctTypes.cpp.

    {
        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
        static const size_t extra_bits = 4;
        static_assert((1 << extra_bits) == BULLETPROOF_MAX_OUTPUTS, "log2(BULLETPROOF_MAX_OUTPUTS) is out of date");
        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
        CHECK_AND_ASSERT_MES(proof.V.size() <= (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
        CHECK_AND_ASSERT_MES(proof.V.size() * 2 > (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
        CHECK_AND_ASSERT_MES(proof.V.size() > 0, 0, "Empty bulletproof");
        return proof.V.size();
    }

Here is the caller graph for this function:

n_bulletproof_amounts() [2/2]

size_t rct::n_bulletproof_amounts

(

const std::vector< Bulletproof > &

proofs

)

Definition at line 264 of file rctTypes.cpp.

    {
        size_t n = 0;
        for (const Bulletproof &proof: proofs)
        {
            size_t n2 = n_bulletproof_amounts(proof);
            CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
            if (n2 == 0)
                return 0;
            n += n2;
        }
        return n;
    }

Here is the call graph for this function:

n_bulletproof_max_amounts() [1/2]

size_t rct::n_bulletproof_max_amounts

(

const Bulletproof &

proof

)

Definition at line 278 of file rctTypes.cpp.

    {
        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
        static const size_t extra_bits = 4;
        static_assert((1 << extra_bits) == BULLETPROOF_MAX_OUTPUTS, "log2(BULLETPROOF_MAX_OUTPUTS) is out of date");
        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
        return 1 << (proof.L.size() - 6);
    }

Here is the caller graph for this function:

n_bulletproof_max_amounts() [2/2]

size_t rct::n_bulletproof_max_amounts

(

const std::vector< Bulletproof > &

proofs

)

Definition at line 288 of file rctTypes.cpp.

    {
        size_t n = 0;
        for (const Bulletproof &proof: proofs)
        {
            size_t n2 = n_bulletproof_max_amounts(proof);
            CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
            if (n2 == 0)
                return 0;
            n += n2;
        }
        return n;
    }

Here is the call graph for this function:

operator<<()

std::ostream & rct::operator<< ( std::ostream & o, const rct::key & v )

inline

Definition at line 576 of file rctTypes.h.

                                                               {
  epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
}

Here is the call graph for this function:

pippenger()

rct::key rct::pippenger	(	const std::vector< MultiexpData > &	data,
		const std::shared_ptr< pippenger_cached_data > &	cache = NULL,
		size_t	cache_size = 0,
		size_t	c = 0 )

pippenger_get_cache_size()

size_t rct::pippenger_get_cache_size

(

const std::shared_ptr< pippenger_cached_data > &

cache

)

pippenger_init_cache()

std::shared_ptr< pippenger_cached_data > rct::pippenger_init_cache	(	const std::vector< MultiexpData > &	data,
		size_t	start_offset = 0,
		size_t	N = 0 )

Here is the caller graph for this function:

pkGen()

key rct::pkGen

(

)

Definition at line 277 of file rctOps.cpp.

                 {
        key sk = skGen();
        key pk = scalarmultBase(sk);
        return pk;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

populateFromBlockchain()

std::tuple< ctkeyM, etn_amount > rct::populateFromBlockchain	(	ctkeyV	inPk,
		int	mixin )

Definition at line 645 of file rctSigs.cpp.

                                                                             {
        int rows = inPk.size();
        ctkeyM rv(mixin + 1, inPk);
        int index = randEtnAmount(mixin);
        int i = 0, j = 0;
        for (i = 0; i <= mixin; i++) {
            if (i != index) {
                for (j = 0; j < rows; j++) {
                    getKeyFromBlockchain(rv[i][j], (size_t)randEtnAmount);
                }
            }
        }
        return make_tuple(rv, index);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

populateFromBlockchainSimple()

etn_amount rct::populateFromBlockchainSimple	(	ctkeyV &	mixRing,
		const ctkey &	inPk,
		int	mixin )

Definition at line 665 of file rctSigs.cpp.

                                                                                             {
        int index = randEtnAmount(mixin);
        int i = 0;
        for (i = 0; i <= mixin; i++) {
            if (i != index) {
                getKeyFromBlockchain(mixRing[i], (size_t)randEtnAmount(1000));
            } else {
                mixRing[i] = inPk;
            }
        }
        return index;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

precomp()

void rct::precomp	(	ge_dsmp	rv,
		const key &	B )

Definition at line 476 of file rctOps.cpp.

                                            {
        ge_p3 B2;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, B.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_dsm_precomp(rv, &B2);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proveRange()

rangeSig rct::proveRange	(	key &	C,
		key &	mask,
		const etn_amount &	amount )

Definition at line 336 of file rctSigs.cpp.

                                                                        {
        sc_0(mask.bytes);
        identity(C);
        bits b;
        d2b(b, amount);
        rangeSig sig;
        key64 ai;
        key64 CiH;
        int i = 0;
        for (i = 0; i < ATOMS; i++) {
            skGen(ai[i]);
            if (b[i] == 0) {
                scalarmultBase(sig.Ci[i], ai[i]);
            }
            if (b[i] == 1) {
                addKeys1(sig.Ci[i], ai[i], H2[i]);
            }
            subKeys(CiH[i], sig.Ci[i], H2[i]);
            sc_add(mask.bytes, mask.bytes, ai[i].bytes);
            addKeys(C, C, sig.Ci[i]);
        }
        sig.asig = genBorromean(ai, sig.Ci, CiH, b);
        return sig;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proveRangeBulletproof()

Bulletproof rct::proveRangeBulletproof	(	keyV &	C,
		keyV &	masks,
		const std::vector< uint64_t > &	amounts,
		epee::span< const key >	sk,
		hw::device &	hwdev )

Definition at line 82 of file rctSigs.cpp.

    {
        CHECK_AND_ASSERT_THROW_MES(amounts.size() == sk.size(), "Invalid amounts/sk sizes");
        masks.resize(amounts.size());
        for (size_t i = 0; i < masks.size(); ++i)
            masks[i] = hwdev.genCommitmentMask(sk[i]);
        Bulletproof proof = bulletproof_PROVE(amounts, masks);
        CHECK_AND_ASSERT_THROW_MES(proof.V.size() == amounts.size(), "V does not have the expected size");
        C = proof.V;
        return proof;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proveRctMG() [1/2]

mgSig rct::proveRctMG	(	const ctkeyM &	pubs,
		const ctkeyV &	inSk,
		const keyV &	outMasks,
		const ctkeyV &	outPk,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		unsigned int	index,
		const key &	txnFee,
		const key &	message,
		hw::device &	hwdev )

Here is the call graph for this function:

proveRctMG() [2/2]

mgSig rct::proveRctMG	(	const key &	message,
		const ctkeyM &	pubs,
		const ctkeyV &	inSk,
		const ctkeyV &	outSk,
		const ctkeyV &	outPk,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		unsigned int	index,
		const key &	txnFeeKey,
		hw::device &	hwdev )

Definition at line 471 of file rctSigs.cpp.

                                                                                                                                                                                                                                   {
        //setup vars
        size_t cols = pubs.size();
        CHECK_AND_ASSERT_THROW_MES(cols >= 1, "Empty pubs");
        size_t rows = pubs[0].size();
        CHECK_AND_ASSERT_THROW_MES(rows >= 1, "Empty pubs");
        for (size_t i = 1; i < cols; ++i) {
          CHECK_AND_ASSERT_THROW_MES(pubs[i].size() == rows, "pubs is not rectangular");
        }
        CHECK_AND_ASSERT_THROW_MES(inSk.size() == rows, "Bad inSk size");
        CHECK_AND_ASSERT_THROW_MES(outSk.size() == outPk.size(), "Bad outSk/outPk size");
        CHECK_AND_ASSERT_THROW_MES((kLRki && mscout) || (!kLRki && !mscout), "Only one of kLRki/mscout is present");
 
        keyV sk(rows + 1);
        keyV tmp(rows + 1);
        size_t i = 0, j = 0;
        for (i = 0; i < rows + 1; i++) {
            sc_0(sk[i].bytes);
            identity(tmp[i]);
        }
        keyM M(cols, tmp);
        //create the matrix to mg sig
        for (i = 0; i < cols; i++) {
            M[i][rows] = identity();
            for (j = 0; j < rows; j++) {
                M[i][j] = pubs[i][j].dest;
                addKeys(M[i][rows], M[i][rows], pubs[i][j].mask); //add input commitments in last row
            }
        }
        sc_0(sk[rows].bytes);
        for (j = 0; j < rows; j++) {
            sk[j] = copy(inSk[j].dest);
            sc_add(sk[rows].bytes, sk[rows].bytes, inSk[j].mask.bytes); //add masks in last row
        }
        for (i = 0; i < cols; i++) {
            for (size_t j = 0; j < outPk.size(); j++) {
                subKeys(M[i][rows], M[i][rows], outPk[j].mask); //subtract output Ci's in last row
            }
            //subtract txn fee output in last row
            subKeys(M[i][rows], M[i][rows], txnFeeKey);
        }
        for (size_t j = 0; j < outPk.size(); j++) {
            sc_sub(sk[rows].bytes, sk[rows].bytes, outSk[j].mask.bytes); //subtract output masks in last row..
        }
        mgSig result = MLSAG_Gen(message, M, sk, kLRki, mscout, index, rows, hwdev);
        memwipe(sk.data(), sk.size() * sizeof(key));
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proveRctMGSimple()

mgSig rct::proveRctMGSimple	(	const key &	message,
		const ctkeyV &	pubs,
		const ctkey &	inSk,
		const key &	a,
		const key &	Cout,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		unsigned int	index,
		hw::device &	hwdev )

Definition at line 528 of file rctSigs.cpp.

                                                                                                                                                                                                       {
        //setup vars
        size_t rows = 1;
        size_t cols = pubs.size();
        CHECK_AND_ASSERT_THROW_MES(cols >= 1, "Empty pubs");
        CHECK_AND_ASSERT_THROW_MES((kLRki && mscout) || (!kLRki && !mscout), "Only one of kLRki/mscout is present");
        keyV tmp(rows + 1);
        keyV sk(rows + 1);
        size_t i;
        keyM M(cols, tmp);
 
        sk[0] = copy(inSk.dest);
        sc_sub(sk[1].bytes, inSk.mask.bytes, a.bytes);
        for (i = 0; i < cols; i++) {
            M[i][0] = pubs[i].dest;
            subKeys(M[i][1], pubs[i].mask, Cout);
        }
        mgSig result = MLSAG_Gen(message, M, sk, kLRki, mscout, index, rows, hwdev);
        memwipe(&sk[0], sizeof(key));
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

randEtnAmount()

etn_amount rct::randEtnAmount

(

etn_amount

upperlimit

)

Definition at line 343 of file rctOps.cpp.

                                                    {
        return h2d(skGen()) % (upperlimit);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

scalarmult8()

key rct::scalarmult8

(

const key &

P

)

Definition at line 398 of file rctOps.cpp.

                                   {
        ge_p3 p3;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&p3, P.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_p2 p2;
        ge_p3_to_p2(&p2, &p3);
        ge_p1p1 p1;
        ge_mul8(&p1, &p2);
        ge_p1p1_to_p2(&p2, &p1);
        rct::key res;
        ge_tobytes(res.bytes, &p2);
        return res;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

scalarmultBase() [1/2]

key rct::scalarmultBase

(

const key &

a

)

Definition at line 358 of file rctOps.cpp.

                                      {
        ge_p3 point;
        key aG;
        sc_reduce32copy(aG.bytes, a.bytes); //do this beforehand
        ge_scalarmult_base(&point, aG.bytes);
        ge_p3_tobytes(aG.bytes, &point);
        return aG;
    }

Here is the call graph for this function:

scalarmultBase() [2/2]

void rct::scalarmultBase	(	key &	aG,
		const key &	a )

Definition at line 350 of file rctOps.cpp.

                                              {
        ge_p3 point;
        sc_reduce32copy(aG.bytes, a.bytes); //do this beforehand!
        ge_scalarmult_base(&point, aG.bytes);
        ge_p3_tobytes(aG.bytes, &point);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

scalarmultH()

key rct::scalarmultH

(

const key &

a

)

Definition at line 389 of file rctOps.cpp.

                                   {
        ge_p2 R;
        ge_scalarmult(&R, a.bytes, &ge_p3_H);
        key aP;
        ge_tobytes(aP.bytes, &R);
        return aP;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

scalarmultKey() [1/2]

key rct::scalarmultKey	(	const key &	P,
		const key &	a )

Definition at line 377 of file rctOps.cpp.

                                                    {
        ge_p3 A;
        ge_p2 R;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A, P.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_scalarmult(&R, a.bytes, &A);
        key aP;
        ge_tobytes(aP.bytes, &R);
        return aP;
    }

Here is the call graph for this function:

scalarmultKey() [2/2]

void rct::scalarmultKey	(	key &	aP,
		const key &	P,
		const key &	a )

Definition at line 368 of file rctOps.cpp.

                                                             {
        ge_p3 A;
        ge_p2 R;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A, P.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_scalarmult(&R, a.bytes, &A);
        ge_tobytes(aP.bytes, &R);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

signMultisig()

bool rct::signMultisig	(	rctSig &	rv,
		const std::vector< unsigned int > &	indices,
		const keyV &	k,
		const multisig_out &	msout,
		const key &	secret_key )

Definition at line 1210 of file rctSigs.cpp.

                                                                                                                                           {
        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2,
            false, "unsupported rct type");
        CHECK_AND_ASSERT_MES(indices.size() == k.size(), false, "Mismatched k/indices sizes");
        CHECK_AND_ASSERT_MES(k.size() == rv.p.MGs.size(), false, "Mismatched k/MGs size");
        CHECK_AND_ASSERT_MES(k.size() == msout.c.size(), false, "Mismatched k/msout.c size");
        if (rv.type == RCTTypeFull)
        {
          CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "MGs not a single element");
        }
        for (size_t n = 0; n < indices.size(); ++n) {
            CHECK_AND_ASSERT_MES(indices[n] < rv.p.MGs[n].ss.size(), false, "Index out of range");
            CHECK_AND_ASSERT_MES(!rv.p.MGs[n].ss[indices[n]].empty(), false, "empty ss line");
        }
 
        for (size_t n = 0; n < indices.size(); ++n) {
            rct::key diff;
            sc_mulsub(diff.bytes, msout.c[n].bytes, secret_key.bytes, k[n].bytes);
            sc_add(rv.p.MGs[n].ss[indices[n]][0].bytes, rv.p.MGs[n].ss[indices[n]][0].bytes, diff.bytes);
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

skGen() [1/2]

key rct::skGen

(

)

Definition at line 258 of file rctOps.cpp.

                {
        key sk;
        skGen(sk);
        return sk;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

skGen() [2/2]

void rct::skGen

(

key &

sk

)

Definition at line 253 of file rctOps.cpp.

                        {
        random32_unbiased(sk.bytes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

skpkGen() [1/2]

std::tuple< key, key > rct::skpkGen

(

)

Definition at line 290 of file rctOps.cpp.

                               {
        key sk = skGen();
        key pk = scalarmultBase(sk);
        return make_tuple(sk, pk);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

skpkGen() [2/2]

void rct::skpkGen	(	key &	sk,
		key &	pk )

Definition at line 284 of file rctOps.cpp.

                                   {
        skGen(sk);
        scalarmultBase(pk, sk);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

skvGen()

keyV rct::skvGen

(

size_t

rows

)

Definition at line 266 of file rctOps.cpp.

                              {
        CHECK_AND_ASSERT_THROW_MES(rows > 0, "0 keys requested");
        keyV rv(rows);
        size_t i = 0;
        for (i = 0 ; i < rows ; i++) {
            skGen(rv[i]);
        }
        return rv;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

straus()

rct::key rct::straus	(	const std::vector< MultiexpData > &	data,
		const std::shared_ptr< straus_cached_data > &	cache = NULL,
		size_t	STEP = 0 )

straus_get_cache_size()

size_t rct::straus_get_cache_size

(

const std::shared_ptr< straus_cached_data > &

cache

)

straus_init_cache()

std::shared_ptr< straus_cached_data > rct::straus_init_cache	(	const std::vector< MultiexpData > &	data,
		size_t	N = 0 )

Here is the caller graph for this function:

subKeys()

void rct::subKeys	(	key &	AB,
		const key &	A,
		const key &	B )

Definition at line 505 of file rctOps.cpp.

                                                       {
        ge_p3 B2, A2;
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, B.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A2, A.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
        ge_cached tmp2;
        ge_p3_to_cached(&tmp2, &B2);
        ge_p1p1 tmp3;
        ge_sub(&tmp3, &A2, &tmp2);
        ge_p1p1_to_p3(&A2, &tmp3);
        ge_p3_tobytes(AB.bytes, &A2);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

sumKeys() [1/2]

void rct::sumKeys	(	key &	Csum,
		const key &	Cis )

sumKeys() [2/2]

void rct::sumKeys	(	key &	Csum,
		const keyV &	Cis )

Definition at line 663 of file rctOps.cpp.

                                                {
        identity(Csum);
        size_t i = 0;
        for (i = 0; i < Cis.size(); i++) {
            addKeys(Csum, Csum, Cis[i]);
        }
    }

Here is the call graph for this function:

toPointCheckOrder() [1/2]

bool rct::toPointCheckOrder	(	ge_p3 *	P,
		const unsigned char *	data )

Definition at line 241 of file rctOps.cpp.

    {
        if (ge_frombytes_vartime(P, data))
            return false;
        ge_p2 R;
        ge_scalarmult(&R, curveOrder().bytes, P);
        key tmp;
        ge_tobytes(tmp.bytes, &R);
        return tmp == identity();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

toPointCheckOrder() [2/2]

bool rct::toPointCheckOrder	(	ge_p3 *	P,
		const unsigned char *	data )

Here is the call graph for this function:

verBulletproof() [1/2]

bool rct::verBulletproof

(

const Bulletproof &

proof

)

Definition at line 94 of file rctSigs.cpp.

    {
      try { return bulletproof_VERIFY(proof); }
      // we can get deep throws from ge_frombytes_vartime if input isn't valid
      catch (...) { return false; }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verBulletproof() [2/2]

bool rct::verBulletproof

(

const std::vector< const Bulletproof * > &

proofs

)

Definition at line 101 of file rctSigs.cpp.

    {
      try { return bulletproof_VERIFY(proofs); }
      // we can get deep throws from ge_frombytes_vartime if input isn't valid
      catch (...) { return false; }
    }

Here is the call graph for this function:

verifyBorromean() [1/2]

bool rct::verifyBorromean	(	const boroSig &	bb,
		const ge_p3	P1[64],
		const ge_p3	P2[64] )

Definition at line 140 of file rctSigs.cpp.

                                                                                    {
        key64 Lv1; key chash, LL;
        int ii = 0;
        ge_p2 p2;
        for (ii = 0 ; ii < 64 ; ii++) {
            // equivalent of: addKeys2(LL, bb.s0[ii], bb.ee, P1[ii]);
            ge_double_scalarmult_base_vartime(&p2, bb.ee.bytes, &P1[ii], bb.s0[ii].bytes);
            ge_tobytes(LL.bytes, &p2);
            chash = hash_to_scalar(LL);
            // equivalent of: addKeys2(Lv1[ii], bb.s1[ii], chash, P2[ii]);
            ge_double_scalarmult_base_vartime(&p2, chash.bytes, &P2[ii], bb.s1[ii].bytes);
            ge_tobytes(Lv1[ii].bytes, &p2);
        }
        key eeComputed = hash_to_scalar(Lv1); //hash function fine
        return equalKeys(eeComputed, bb.ee);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verifyBorromean() [2/2]

bool rct::verifyBorromean	(	const boroSig &	bb,
		const key64	P1,
		const key64	P2 )

Definition at line 157 of file rctSigs.cpp.

                                                                            {
      ge_p3 P1_p3[64], P2_p3[64];
      for (size_t i = 0 ; i < 64 ; ++i) {
        CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&P1_p3[i], P1[i].bytes) == 0, false, "point conv failed");
        CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&P2_p3[i], P2[i].bytes) == 0, false, "point conv failed");
      }
      return verifyBorromean(bb, P1_p3, P2_p3);
    }

Here is the call graph for this function:

verRange()

bool rct::verRange	(	const key &	C,
		const rangeSig &	as )

Definition at line 368 of file rctSigs.cpp.

                                                      {
      try
      {
        PERF_TIMER(verRange);
        ge_p3 CiH[64], asCi[64];
        int i = 0;
        ge_p3 Ctmp_p3 = ge_p3_identity;
        for (i = 0; i < 64; i++) {
            // faster equivalent of:
            // subKeys(CiH[i], as.Ci[i], H2[i]);
            // addKeys(Ctmp, Ctmp, as.Ci[i]);
            ge_cached cached;
            ge_p3 p3;
            ge_p1p1 p1;
            CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&p3, H2[i].bytes) == 0, false, "point conv failed");
            ge_p3_to_cached(&cached, &p3);
            CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&asCi[i], as.Ci[i].bytes) == 0, false, "point conv failed");
            ge_sub(&p1, &asCi[i], &cached);
            ge_p3_to_cached(&cached, &asCi[i]);
            ge_p1p1_to_p3(&CiH[i], &p1);
            ge_add(&p1, &Ctmp_p3, &cached);
            ge_p1p1_to_p3(&Ctmp_p3, &p1);
        }
        key Ctmp;
        ge_p3_tobytes(Ctmp.bytes, &Ctmp_p3);
        if (!equalKeys(C, Ctmp))
          return false;
        if (!verifyBorromean(as.asig, asCi, CiH))
          return false;
        return true;
      }
      // we can get deep throws from ge_frombytes_vartime if input isn't valid
      catch (...) { return false; }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verRct() [1/2]

bool rct::verRct	(	const rctSig &	rv,
		bool	semantics )

Definition at line 913 of file rctSigs.cpp.

                                                   {
        PERF_TIMER(verRct);
        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "verRct called on non-full rctSig");
        if (semantics)
        {
          CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.p.rangeSigs.size(), false, "Mismatched sizes of outPk and rv.p.rangeSigs");
          CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.ecdhInfo.size(), false, "Mismatched sizes of outPk and rv.ecdhInfo");
          CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "full rctSig has not one MG");
        }
        else
        {
          // semantics check is early, we don't have the MGs resolved yet
        }
 
        // some rct ops can throw
        try
        {
          if (semantics) {
            tools::threadpool& tpool = tools::threadpool::getInstance();
            tools::threadpool::waiter waiter;
            std::deque<bool> results(rv.outPk.size(), false);
            DP("range proofs verified?");
            for (size_t i = 0; i < rv.outPk.size(); i++)
              tpool.submit(&waiter, [&, i] { results[i] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
            waiter.wait(&tpool);
 
            for (size_t i = 0; i < results.size(); ++i) {
              if (!results[i]) {
                LOG_PRINT_L1("Range proof verified failed for proof " << i);
                return false;
              }
            }
          }
 
          if (!semantics) {
            //compute txn fee
            key txnFeeKey = scalarmultH(d2h(rv.txnFee));
            bool mgVerd = verRctMG(rv.p.MGs[0], rv.mixRing, rv.outPk, txnFeeKey, get_pre_mlsag_hash(rv, hw::get_device("default")));
            DP("mg sig verified?");
            DP(mgVerd);
            if (!mgVerd) {
              LOG_PRINT_L1("MG signature verification failed");
              return false;
            }
          }
 
          return true;
        }
        catch (const std::exception &e)
        {
          LOG_PRINT_L1("Error in verRct: " << e.what());
          return false;
        }
        catch (...)
        {
          LOG_PRINT_L1("Error in verRct, but not an actual exception");
          return false;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verRct() [2/2]

bool rct::verRct	(	const rctSig &	rv,
		bool	semantics )

verRctMG()

bool rct::verRctMG	(	const mgSig &	mg,
		const ctkeyM &	pubs,
		const ctkeyV &	outPk,
		const key &	txnFeeKey,
		const key &	message )

Definition at line 559 of file rctSigs.cpp.

                                                                                                                        {
        PERF_TIMER(verRctMG);
        //setup vars
        size_t cols = pubs.size();
        CHECK_AND_ASSERT_MES(cols >= 1, false, "Empty pubs");
        size_t rows = pubs[0].size();
        CHECK_AND_ASSERT_MES(rows >= 1, false, "Empty pubs");
        for (size_t i = 1; i < cols; ++i) {
          CHECK_AND_ASSERT_MES(pubs[i].size() == rows, false, "pubs is not rectangular");
        }
 
        keyV tmp(rows + 1);
        size_t i = 0, j = 0;
        for (i = 0; i < rows + 1; i++) {
            identity(tmp[i]);
        }
        keyM M(cols, tmp);
 
        //create the matrix to mg sig
        for (j = 0; j < rows; j++) {
            for (i = 0; i < cols; i++) {
                M[i][j] = pubs[i][j].dest;
                addKeys(M[i][rows], M[i][rows], pubs[i][j].mask); //add Ci in last row
            }
        }
        for (i = 0; i < cols; i++) {
            for (j = 0; j < outPk.size(); j++) {
                subKeys(M[i][rows], M[i][rows], outPk[j].mask); //subtract output Ci's in last row
            }
            //subtract txn fee output in last row
            subKeys(M[i][rows], M[i][rows], txnFeeKey);
        }
        return MLSAG_Ver(message, M, mg, rows);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verRctMGSimple()

bool rct::verRctMGSimple	(	const key &	message,
		const mgSig &	mg,
		const ctkeyV &	pubs,
		const key &	C )

Definition at line 598 of file rctSigs.cpp.

                                                                                                 {
        try
        {
            PERF_TIMER(verRctMGSimple);
            //setup vars
            size_t rows = 1;
            size_t cols = pubs.size();
            CHECK_AND_ASSERT_MES(cols >= 1, false, "Empty pubs");
            keyV tmp(rows + 1);
            size_t i;
            keyM M(cols, tmp);
            ge_p3 Cp3;
            CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&Cp3, C.bytes) == 0, false, "point conv failed");
            ge_cached Ccached;
            ge_p3_to_cached(&Ccached, &Cp3);
            ge_p1p1 p1;
            //create the matrix to mg sig
            for (i = 0; i < cols; i++) {
                    M[i][0] = pubs[i].dest;
                    ge_p3 p3;
                    CHECK_AND_ASSERT_MES_L1(ge_frombytes_vartime(&p3, pubs[i].mask.bytes) == 0, false, "point conv failed");
                    ge_sub(&p1, &p3, &Ccached);
                    ge_p1p1_to_p3(&p3, &p1);
                    ge_p3_tobytes(M[i][1].bytes, &p3);
            }
            //DP(C);
            return MLSAG_Ver(message, M, mg, rows);
        }
        catch (...) { return false; }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verRctNonSemanticsSimple()

bool rct::verRctNonSemanticsSimple

(

const rctSig &

rv

)

Definition at line 1085 of file rctSigs.cpp.

                                                     {
      try
      {
        PERF_TIMER(verRctNonSemanticsSimple);
 
        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2,
            false, "verRctNonSemanticsSimple called on non simple rctSig");
        const bool bulletproof = is_rct_bulletproof(rv.type);
        // semantics check is early, and mixRing/MGs aren't resolved yet
        if (bulletproof)
          CHECK_AND_ASSERT_MES(rv.p.pseudoOuts.size() == rv.mixRing.size(), false, "Mismatched sizes of rv.p.pseudoOuts and mixRing");
        else
          CHECK_AND_ASSERT_MES(rv.pseudoOuts.size() == rv.mixRing.size(), false, "Mismatched sizes of rv.pseudoOuts and mixRing");
 
        const size_t threads = std::max(rv.outPk.size(), rv.mixRing.size());
 
        std::deque<bool> results(threads);
        tools::threadpool& tpool = tools::threadpool::getInstance();
        tools::threadpool::waiter waiter;
 
        const keyV &pseudoOuts = bulletproof ? rv.p.pseudoOuts : rv.pseudoOuts;
 
        const key message = get_pre_mlsag_hash(rv, hw::get_device("default"));
 
        results.clear();
        results.resize(rv.mixRing.size());
        for (size_t i = 0 ; i < rv.mixRing.size() ; i++) {
          tpool.submit(&waiter, [&, i] {
              results[i] = verRctMGSimple(message, rv.p.MGs[i], rv.mixRing[i], pseudoOuts[i]);
          });
        }
        waiter.wait(&tpool);
 
        for (size_t i = 0; i < results.size(); ++i) {
          if (!results[i]) {
            LOG_PRINT_L1("verRctMGSimple failed for input " << i);
            return false;
          }
        }
 
        return true;
      }
      // we can get deep throws from ge_frombytes_vartime if input isn't valid
      catch (const std::exception &e)
      {
        LOG_PRINT_L1("Error in verRctNonSemanticsSimple: " << e.what());
        return false;
      }
      catch (...)
      {
        LOG_PRINT_L1("Error in verRctNonSemanticsSimple, but not an actual exception");
        return false;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verRctSemanticsSimple() [1/2]

bool rct::verRctSemanticsSimple

(

const rctSig &

rv

)

Definition at line 1078 of file rctSigs.cpp.

    {
      return verRctSemanticsSimple(std::vector<const rctSig*>(1, &rv));
    }

Here is the call graph for this function:

verRctSemanticsSimple() [2/2]

bool rct::verRctSemanticsSimple

(

const std::vector< const rctSig * > &

rvv

)

Definition at line 975 of file rctSigs.cpp.

                                                                     {
      try
      {
        PERF_TIMER(verRctSemanticsSimple);
 
        tools::threadpool& tpool = tools::threadpool::getInstance();
        tools::threadpool::waiter waiter;
        std::deque<bool> results;
        std::vector<const Bulletproof*> proofs;
        size_t max_non_bp_proofs = 0, offset = 0;
 
        for (const rctSig *rvp: rvv)
        {
          CHECK_AND_ASSERT_MES(rvp, false, "rctSig pointer is NULL");
          const rctSig &rv = *rvp;
          CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2,
              false, "verRctSemanticsSimple called on non simple rctSig");
          const bool bulletproof = is_rct_bulletproof(rv.type);
          if (bulletproof)
          {
            CHECK_AND_ASSERT_MES(rv.outPk.size() == n_bulletproof_amounts(rv.p.bulletproofs), false, "Mismatched sizes of outPk and bulletproofs");
            CHECK_AND_ASSERT_MES(rv.p.pseudoOuts.size() == rv.p.MGs.size(), false, "Mismatched sizes of rv.p.pseudoOuts and rv.p.MGs");
            CHECK_AND_ASSERT_MES(rv.pseudoOuts.empty(), false, "rv.pseudoOuts is not empty");
          }
          else
          {
            CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.p.rangeSigs.size(), false, "Mismatched sizes of outPk and rv.p.rangeSigs");
            CHECK_AND_ASSERT_MES(rv.pseudoOuts.size() == rv.p.MGs.size(), false, "Mismatched sizes of rv.pseudoOuts and rv.p.MGs");
            CHECK_AND_ASSERT_MES(rv.p.pseudoOuts.empty(), false, "rv.p.pseudoOuts is not empty");
          }
          CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.ecdhInfo.size(), false, "Mismatched sizes of outPk and rv.ecdhInfo");
 
          if (!bulletproof)
            max_non_bp_proofs += rv.p.rangeSigs.size();
        }
 
        results.resize(max_non_bp_proofs);
        for (const rctSig *rvp: rvv)
        {
          const rctSig &rv = *rvp;
 
          const bool bulletproof = is_rct_bulletproof(rv.type);
          const keyV &pseudoOuts = bulletproof ? rv.p.pseudoOuts : rv.pseudoOuts;
 
          rct::keyV masks(rv.outPk.size());
          for (size_t i = 0; i < rv.outPk.size(); i++) {
            masks[i] = rv.outPk[i].mask;
          }
          key sumOutpks = addKeys(masks);
          DP(sumOutpks);
          const key txnFeeKey = scalarmultH(d2h(rv.txnFee));
          addKeys(sumOutpks, txnFeeKey, sumOutpks);
 
          key sumPseudoOuts = addKeys(pseudoOuts);
          DP(sumPseudoOuts);
 
          //check pseudoOuts vs Outs..
          if (!equalKeys(sumPseudoOuts, sumOutpks)) {
            LOG_PRINT_L1("Sum check failed");
            return false;
          }
 
          if (bulletproof)
          {
            for (size_t i = 0; i < rv.p.bulletproofs.size(); i++)
              proofs.push_back(&rv.p.bulletproofs[i]);
          }
          else
          {
            for (size_t i = 0; i < rv.p.rangeSigs.size(); i++)
              tpool.submit(&waiter, [&, i, offset] { results[i+offset] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
            offset += rv.p.rangeSigs.size();
          }
        }
        if (!proofs.empty() && !verBulletproof(proofs))
        {
          LOG_PRINT_L1("Aggregate range proof verified failed");
          return false;
        }
 
        waiter.wait(&tpool);
        for (size_t i = 0; i < results.size(); ++i) {
          if (!results[i]) {
            LOG_PRINT_L1("Range proof verified failed for proof " << i);
            return false;
          }
        }
 
        return true;
      }
      // we can get deep throws from ge_frombytes_vartime if input isn't valid
      catch (const std::exception &e)
      {
        LOG_PRINT_L1("Error in verRctSemanticsSimple: " << e.what());
        return false;
      }
      catch (...)
      {
        LOG_PRINT_L1("Error in verRctSemanticsSimple, but not an actual exception");
        return false;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

zero() [1/2]

key rct::zero ( )

inline

Definition at line 70 of file rctOps.h.

{ return Z; }

Here is the caller graph for this function:

zero() [2/2]

void rct::zero ( key & z )

inline

Definition at line 71 of file rctOps.h.

{ memset(&z, 0, 32); }

zeroCommit()

key rct::zeroCommit

(

etn_amount

amount

)

Definition at line 322 of file rctOps.cpp.

                                      {
        const zero_commitment *begin = zero_commitments;
        const zero_commitment *end = zero_commitments + sizeof(zero_commitments) / sizeof(zero_commitments[0]);
        const zero_commitment value{amount, rct::zero()};
        const auto it = std::lower_bound(begin, end, value, [](const zero_commitment &e0, const zero_commitment &e1){ return e0.amount < e1.amount; });
        if (it != end && it->amount == amount)
        {
            return it->commitment;
        }
        key am = d2h(amount);
        key bH = scalarmultH(am);
        return addKeys(G, bH);
    }

Here is the call graph for this function:

Here is the caller graph for this function: