crypto Namespace Reference

crypto namespace. More...

Namespaces
	ElectrumWords
	Mnemonic seed word generation and wallet restoration helper functions.

Classes
class	crypto_ops
struct	ec_point_pair
struct	ge_cached
struct	ge_p1p1
struct	ge_p2
struct	ge_p3
struct	ge_precomp
union	hash_state
struct	random_device
struct	rs_comm
struct	s_comm
struct	s_comm_2

Typedefs
typedef int32_t	fe[10]
typedef ge_cached	ge_dsmp[8]
using	secret_key = epee::mlocked< tools::scrubbed< ec_scalar > >

Enumerations
enum	{ HASH_SIZE = 32, HASH_DATA_AREA = 136 }

Functions
void	ge_add (ge_p1p1 *, const ge_p3 *, const ge_cached *)
void	ge_dsm_precomp (ge_dsmp r, const ge_p3 *s)
void	ge_double_scalarmult_base_vartime (ge_p2 *, const unsigned char *, const ge_p3 *, const unsigned char *)
void	ge_double_scalarmult_base_vartime_p3 (ge_p3 *, const unsigned char *, const ge_p3 *, const unsigned char *)
int	ge_frombytes_vartime (ge_p3 *, const unsigned char *)
void	ge_p1p1_to_p2 (ge_p2 *, const ge_p1p1 *)
void	ge_p1p1_to_p3 (ge_p3 *, const ge_p1p1 *)
void	ge_p2_dbl (ge_p1p1 *, const ge_p2 *)
void	ge_p3_to_cached (ge_cached *, const ge_p3 *)
void	ge_p3_to_p2 (ge_p2 *, const ge_p3 *)
void	ge_p3_tobytes (unsigned char *, const ge_p3 *)
void	ge_scalarmult_base (ge_p3 *, const unsigned char *)
void	ge_tobytes (unsigned char *, const ge_p2 *)
void	sc_reduce (unsigned char *)
void	ge_scalarmult (ge_p2 *, const unsigned char *, const ge_p3 *)
void	ge_scalarmult_p3 (ge_p3 *, const unsigned char *, const ge_p3 *)
void	ge_double_scalarmult_precomp_vartime (ge_p2 *, const unsigned char *, const ge_p3 *, const unsigned char *, const ge_dsmp)
void	ge_double_scalarmult_precomp_vartime2 (ge_p2 *, const unsigned char *, const ge_dsmp, const unsigned char *, const ge_dsmp)
void	ge_double_scalarmult_precomp_vartime2_p3 (ge_p3 *, const unsigned char *, const ge_dsmp, const unsigned char *, const ge_dsmp)
void	ge_mul8 (ge_p1p1 *, const ge_p2 *)
void	ge_fromfe_frombytes_vartime (ge_p2 *, const unsigned char *)
void	sc_0 (unsigned char *)
void	sc_reduce32 (unsigned char *)
void	sc_add (unsigned char *, const unsigned char *, const unsigned char *)
void	sc_sub (unsigned char *, const unsigned char *, const unsigned char *)
void	sc_mulsub (unsigned char *, const unsigned char *, const unsigned char *, const unsigned char *)
void	sc_mul (unsigned char *, const unsigned char *, const unsigned char *)
void	sc_muladd (unsigned char *s, const unsigned char *a, const unsigned char *b, const unsigned char *c)
int	sc_check (const unsigned char *)
int	sc_isnonzero (const unsigned char *)
uint64_t	load_3 (const unsigned char *in)
uint64_t	load_4 (const unsigned char *in)
void	ge_sub (ge_p1p1 *r, const ge_p3 *p, const ge_cached *q)
void	fe_add (fe h, const fe f, const fe g)
void	fe_tobytes (unsigned char *, const fe)
void	fe_invert (fe out, const fe z)
int	ge_p3_is_point_at_infinity (const ge_p3 *p)
void	generate_random_bytes_not_thread_safe (size_t n, void *result)
static unsigned char *	operator& (ec_point &point)
static const unsigned char *	operator& (const ec_point &point)
static unsigned char *	operator& (ec_scalar &scalar)
static const unsigned char *	operator& (const ec_scalar &scalar)
void	generate_random_bytes_thread_safe (size_t N, uint8_t *bytes)
static bool	less32 (const unsigned char *k0, const unsigned char *k1)
void	random32_unbiased (unsigned char *bytes)
void	random_scalar (ec_scalar &res)
void	hash_to_scalar (const void *data, size_t length, ec_scalar &res)
void	hash_to_ec (const public_key &key, ge_p3 &res)
size_t	rs_comm_size (size_t pubs_count)
void	rand (size_t N, uint8_t *bytes)
template<typename T >
std::enable_if< std::is_pod< T >::value, T >::type	rand ()
template<typename T >
std::enable_if< std::is_integral< T >::value, T >::type	rand_range (T range_min, T range_max)
template<typename T >
std::enable_if< std::is_unsigned< T >::value, T >::type	rand_idx (T sz)
secret_key	generate_keys (public_key &pub, secret_key &sec, const secret_key &recovery_key=secret_key(), bool recover=false)
bool	check_key (const public_key &key)
bool	secret_key_to_public_key (const secret_key &sec, public_key &pub)
bool	generate_key_derivation (const public_key &key1, const secret_key &key2, key_derivation &derivation)
bool	derive_public_key (const key_derivation &derivation, std::size_t output_index, const public_key &base, public_key &derived_key)
void	derivation_to_scalar (const key_derivation &derivation, size_t output_index, ec_scalar &res)
void	derive_secret_key (const key_derivation &derivation, std::size_t output_index, const secret_key &base, secret_key &derived_key)
bool	derive_subaddress_public_key (const public_key &out_key, const key_derivation &derivation, std::size_t output_index, public_key &result)
void	generate_signature (const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig)
bool	check_signature (const hash &prefix_hash, const public_key &pub, const signature &sig)
void	generate_tx_proof (const hash &prefix_hash, const public_key &R, const public_key &A, const boost::optional< public_key > &B, const public_key &D, const secret_key &r, signature &sig)
bool	check_tx_proof (const hash &prefix_hash, const public_key &R, const public_key &A, const boost::optional< public_key > &B, const public_key &D, const signature &sig)
void	generate_key_image (const public_key &pub, const secret_key &sec, key_image &image)
void	generate_ring_signature (const hash &prefix_hash, const key_image &image, const public_key *const *pubs, std::size_t pubs_count, const secret_key &sec, std::size_t sec_index, signature *sig)
bool	check_ring_signature (const hash &prefix_hash, const key_image &image, const public_key *const *pubs, std::size_t pubs_count, const signature *sig)
void	generate_ring_signature (const hash &prefix_hash, const key_image &image, const std::vector< const public_key *> &pubs, const secret_key &sec, std::size_t sec_index, signature *sig)
bool	check_ring_signature (const hash &prefix_hash, const key_image &image, const std::vector< const public_key *> &pubs, const signature *sig)
std::ostream &	operator<< (std::ostream &o, const crypto::public_key &v)
std::ostream &	operator<< (std::ostream &o, const crypto::secret_key &v)
std::ostream &	operator<< (std::ostream &o, const crypto::key_derivation &v)
std::ostream &	operator<< (std::ostream &o, const crypto::key_image &v)
std::ostream &	operator<< (std::ostream &o, const crypto::signature &v)
std::string	sign_message (const std::string &message, const std::string &privateKey)
bool	verify_signature (const std::string &message, const std::string &publicKey, const std::string &signature)
bool	verify_signature (const std::string &message, std::vector< std::string > publicKey, const std::string &signature)
std::vector< std::string >	create_ed25519_keypair ()
std::string	base64_decode (const std::string &val)
std::string	base64_encode (const std::string &val)
static void *	padd (void *p, size_t i)
static const void *	cpadd (const void *p, size_t i)
static void	place_length (uint8_t *buffer, size_t bufsize, size_t length)
void	hash_permutation (union hash_state *state)
void	hash_process (union hash_state *state, const uint8_t *buf, size_t count)
void	cn_fast_hash (const void *data, size_t length, char *hash)
void	cn_slow_hash (const void *data, size_t length, char *hash, int variant, int prehashed, uint64_t height)
void	hash_extra_blake (const void *data, size_t length, char *hash)
void	hash_extra_groestl (const void *data, size_t length, char *hash)
void	hash_extra_jh (const void *data, size_t length, char *hash)
void	hash_extra_skein (const void *data, size_t length, char *hash)
void	tree_hash (const char(*hashes)[HASH_SIZE], size_t count, char *root_hash)
void	cn_fast_hash (const void *data, std::size_t length, hash &hash)
hash	cn_fast_hash (const void *data, std::size_t length)
void	cn_slow_hash (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	cn_slow_hash_prehashed (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	tree_hash (const hash *hashes, std::size_t count, hash &root_hash)
std::ostream &	operator<< (std::ostream &o, const crypto::hash &v)
std::ostream &	operator<< (std::ostream &o, const crypto::hash8 &v)
std::ostream &	operator<< (std::ostream &o, const crypto::hash64 &v)

Variables
const ge_precomp	ge_Bi [8]
const fe	fe_sqrtm1
const fe	fe_d
const fe	fe_d2
const ge_precomp	ge_base [32][8]
const fe	fe_ma2
const fe	fe_ma
const fe	fe_fffb1
const fe	fe_fffb2
const fe	fe_fffb3
const fe	fe_fffb4
const ge_p3	ge_p3_identity
const ge_p3	ge_p3_H
const crypto::public_key	null_pkey = crypto::public_key{}
const crypto::secret_key	null_skey = crypto::secret_key{}
POD_CLASS	ec_point
POD_CLASS	ec_scalar
POD_CLASS	public_key
POD_CLASS	public_keyV
int	rows
POD_CLASS	secret_keyV
POD_CLASS	public_keyM
std::vector< secret_keyV >	column_vectors
POD_CLASS	key_derivation
POD_CLASS	key_image
POD_CLASS	signature
	PUSH_WARNINGS
POD_CLASS	hash
POD_CLASS	hash8
POD_CLASS	hash64
static const crypto::hash	null_hash = boost::value_initialized<crypto::hash>()
static const crypto::hash8	null_hash8 = boost::value_initialized<crypto::hash8>()
static const crypto::hash64	null_hash64 = boost::value_initialized<crypto::hash64>()

Detailed Description

crypto namespace.

Typedef Documentation

fe

typedef int32_t crypto::fe[10]

ge_dsmp

typedef ge_cached crypto::ge_dsmp[8]

secret_key

using crypto::secret_key = typedef epee::mlocked<tools::scrubbed<ec_scalar> >

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
HASH_SIZE
HASH_DATA_AREA

Function Documentation

base64_decode()

std::string crypto::base64_decode ( const std::string &  val )

inline

base64_encode()

std::string crypto::base64_encode ( const std::string &  val )

inline

check_key()

bool crypto::check_key ( const public_key &  key )

inline

check_ring_signature() [1/2]

bool crypto::check_ring_signature ( const hash &  prefix_hash, const key_image &  image, const public_key *const *  pubs, std::size_t  pubs_count, const signature *  sig  )

inline

check_ring_signature() [2/2]

bool crypto::check_ring_signature ( const hash &  prefix_hash, const key_image &  image, const std::vector< const public_key *> &  pubs, const signature *  sig  )

inline

check_signature()

bool crypto::check_signature ( const hash &  prefix_hash, const public_key &  pub, const signature &  sig  )

inline

check_tx_proof()

bool crypto::check_tx_proof ( const hash &  prefix_hash, const public_key &  R, const public_key &  A, const boost::optional< public_key > &  B, const public_key &  D, const signature &  sig  )

inline

cn_fast_hash() [1/3]

void crypto::cn_fast_hash ( const void *  data, std::size_t  length, hash &  hash  )

inline

cn_fast_hash() [2/3]

hash crypto::cn_fast_hash ( const void *  data, std::size_t  length  )

inline

cn_fast_hash() [3/3]

void crypto::cn_fast_hash	(	const void *	data,
		size_t	length,
		char *	hash
	)

cn_slow_hash() [1/2]

void crypto::cn_slow_hash ( const void *  data, std::size_t  length, hash &  hash, int  variant = 0, uint64_t  height = 0  )

inline

cn_slow_hash() [2/2]

void crypto::cn_slow_hash	(	const void *	data,
		size_t	length,
		char *	hash,
		int	variant,
		int	prehashed,
		uint64_t	height
	)

cn_slow_hash_prehashed()

void crypto::cn_slow_hash_prehashed ( const void *  data, std::size_t  length, hash &  hash, int  variant = 0, uint64_t  height = 0  )

inline

cpadd()

static const void* crypto::cpadd ( const void *  p, size_t  i  )

inlinestatic

create_ed25519_keypair()

std::vector<std::string> crypto::create_ed25519_keypair ( )

inline

derivation_to_scalar()

void crypto::derivation_to_scalar ( const key_derivation &  derivation, size_t  output_index, ec_scalar &  res  )

inline

derive_public_key()

bool crypto::derive_public_key ( const key_derivation &  derivation, std::size_t  output_index, const public_key &  base, public_key &  derived_key  )

inline

derive_secret_key()

void crypto::derive_secret_key ( const key_derivation &  derivation, std::size_t  output_index, const secret_key &  base, secret_key &  derived_key  )

inline

derive_subaddress_public_key()

bool crypto::derive_subaddress_public_key ( const public_key &  out_key, const key_derivation &  derivation, std::size_t  output_index, public_key &  result  )

inline

fe_add()

void crypto::fe_add	(	fe	h,
		const fe	f,
		const fe	g
	)

fe_invert()

void crypto::fe_invert	(	fe	out,
		const fe	z
	)

fe_tobytes()

void crypto::fe_tobytes	(	unsigned char *	,
		const fe
	)

ge_add()

void crypto::ge_add	(	ge_p1p1 *	,
		const ge_p3 *	,
		const ge_cached *
	)

ge_double_scalarmult_base_vartime()

void crypto::ge_double_scalarmult_base_vartime	(	ge_p2 *	,
		const unsigned char *	,
		const ge_p3 *	,
		const unsigned char *
	)

ge_double_scalarmult_base_vartime_p3()

void crypto::ge_double_scalarmult_base_vartime_p3	(	ge_p3 *	,
		const unsigned char *	,
		const ge_p3 *	,
		const unsigned char *
	)

ge_double_scalarmult_precomp_vartime()

void crypto::ge_double_scalarmult_precomp_vartime	(	ge_p2 *	,
		const unsigned char *	,
		const ge_p3 *	,
		const unsigned char *	,
		const ge_dsmp
	)

ge_double_scalarmult_precomp_vartime2()

void crypto::ge_double_scalarmult_precomp_vartime2	(	ge_p2 *	,
		const unsigned char *	,
		const ge_dsmp	,
		const unsigned char *	,
		const ge_dsmp
	)

ge_double_scalarmult_precomp_vartime2_p3()

void crypto::ge_double_scalarmult_precomp_vartime2_p3	(	ge_p3 *	,
		const unsigned char *	,
		const ge_dsmp	,
		const unsigned char *	,
		const ge_dsmp
	)

ge_dsm_precomp()

void crypto::ge_dsm_precomp	(	ge_dsmp	r,
		const ge_p3 *	s
	)

ge_frombytes_vartime()

int crypto::ge_frombytes_vartime	(	ge_p3 *	,
		const unsigned char *
	)

ge_fromfe_frombytes_vartime()

void crypto::ge_fromfe_frombytes_vartime	(	ge_p2 *	,
		const unsigned char *
	)

ge_mul8()

void crypto::ge_mul8	(	ge_p1p1 *	,
		const ge_p2 *
	)

ge_p1p1_to_p2()

void crypto::ge_p1p1_to_p2	(	ge_p2 *	,
		const ge_p1p1 *
	)

ge_p1p1_to_p3()

void crypto::ge_p1p1_to_p3	(	ge_p3 *	,
		const ge_p1p1 *
	)

ge_p2_dbl()

void crypto::ge_p2_dbl	(	ge_p1p1 *	,
		const ge_p2 *
	)

ge_p3_is_point_at_infinity()

int crypto::ge_p3_is_point_at_infinity

(

const ge_p3 *

p

)

ge_p3_to_cached()

void crypto::ge_p3_to_cached	(	ge_cached *	,
		const ge_p3 *
	)

ge_p3_to_p2()

void crypto::ge_p3_to_p2	(	ge_p2 *	,
		const ge_p3 *
	)

ge_p3_tobytes()

void crypto::ge_p3_tobytes	(	unsigned char *	,
		const ge_p3 *
	)

ge_scalarmult()

void crypto::ge_scalarmult	(	ge_p2 *	,
		const unsigned char *	,
		const ge_p3 *
	)

ge_scalarmult_base()

void crypto::ge_scalarmult_base	(	ge_p3 *	,
		const unsigned char *
	)

ge_scalarmult_p3()

void crypto::ge_scalarmult_p3	(	ge_p3 *	,
		const unsigned char *	,
		const ge_p3 *
	)

ge_sub()

void crypto::ge_sub	(	ge_p1p1 *	r,
		const ge_p3 *	p,
		const ge_cached *	q
	)

ge_tobytes()

void crypto::ge_tobytes	(	unsigned char *	,
		const ge_p2 *
	)

generate_key_derivation()

bool crypto::generate_key_derivation ( const public_key &  key1, const secret_key &  key2, key_derivation &  derivation  )

inline

generate_key_image()

void crypto::generate_key_image ( const public_key &  pub, const secret_key &  sec, key_image &  image  )

inline

generate_keys()

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

inline

generate_random_bytes_not_thread_safe()

void crypto::generate_random_bytes_not_thread_safe	(	size_t	n,
		void *	result
	)

generate_random_bytes_thread_safe()

void crypto::generate_random_bytes_thread_safe	(	size_t	N,
		uint8_t *	bytes
	)

generate_ring_signature() [1/2]

void crypto::generate_ring_signature ( const hash &  prefix_hash, const key_image &  image, const public_key *const *  pubs, std::size_t  pubs_count, const secret_key &  sec, std::size_t  sec_index, signature *  sig  )

inline

generate_ring_signature() [2/2]

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

inline

generate_signature()

void crypto::generate_signature ( const hash &  prefix_hash, const public_key &  pub, const secret_key &  sec, signature &  sig  )

inline

generate_tx_proof()

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

inline

hash_extra_blake()

void crypto::hash_extra_blake	(	const void *	data,
		size_t	length,
		char *	hash
	)

hash_extra_groestl()

void crypto::hash_extra_groestl	(	const void *	data,
		size_t	length,
		char *	hash
	)

hash_extra_jh()

void crypto::hash_extra_jh	(	const void *	data,
		size_t	length,
		char *	hash
	)

hash_extra_skein()

void crypto::hash_extra_skein	(	const void *	data,
		size_t	length,
		char *	hash
	)

hash_permutation()

void crypto::hash_permutation

(

union hash_state *

state

)

hash_process()

void crypto::hash_process	(	union hash_state *	state,
		const uint8_t *	buf,
		size_t	count
	)

hash_to_ec()

POP_WARNINGS void crypto::hash_to_ec	(	const public_key &	key,
		ge_p3 &	res
	)

hash_to_scalar()

void crypto::hash_to_scalar	(	const void *	data,
		size_t	length,
		ec_scalar &	res
	)

less32()

static bool crypto::less32 ( const unsigned char *  k0, const unsigned char *  k1  )

inlinestatic

load_3()

uint64_t crypto::load_3

(

const unsigned char *

in

)

load_4()

uint64_t crypto::load_4

(

const unsigned char *

in

)

operator&() [1/4]

static unsigned char* crypto::operator & ( ec_point &  point )

inlinestatic

operator&() [2/4]

static const unsigned char* crypto::operator & ( const ec_point &  point )

inlinestatic

operator&() [3/4]

static unsigned char* crypto::operator & ( ec_scalar &  scalar )

inlinestatic

operator&() [4/4]

static const unsigned char* crypto::operator & ( const ec_scalar &  scalar )

inlinestatic

operator<<() [1/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::hash &  v  )

inline

operator<<() [2/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::hash8 &  v  )

inline

operator<<() [3/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::hash64 &  v  )

inline

operator<<() [4/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::public_key &  v  )

inline

operator<<() [5/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::secret_key &  v  )

inline

operator<<() [6/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::key_derivation &  v  )

inline

operator<<() [7/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::key_image &  v  )

inline

operator<<() [8/8]

std::ostream& crypto::operator<< ( std::ostream &  o, const crypto::signature &  v  )

inline

padd()

static void* crypto::padd ( void *  p, size_t  i  )

inlinestatic

place_length()

static void crypto::place_length ( uint8_t *  buffer, size_t  bufsize, size_t  length  )

inlinestatic

rand() [1/2]

void crypto::rand ( size_t  N, uint8_t *  bytes  )

inline

rand() [2/2]

template<typename T >

std::enable_if<std::is_pod<T>::value, T>::type crypto::rand

(

)

rand_idx()

template<typename T >

std::enable_if<std::is_unsigned<T>::value, T>::type crypto::rand_idx

(

T

sz

)

rand_range()

template<typename T >

std::enable_if<std::is_integral<T>::value, T>::type crypto::rand_range	(	T	range_min,
		T	range_max
	)

random32_unbiased()

void crypto::random32_unbiased

(

unsigned char *

bytes

)

random_scalar()

void crypto::random_scalar

(

ec_scalar &

res

)

rs_comm_size()

size_t crypto::rs_comm_size

(

size_t

pubs_count

)

sc_0()

void crypto::sc_0

(

unsigned char *

)

sc_add()

void crypto::sc_add	(	unsigned char *	,
		const unsigned char *	,
		const unsigned char *
	)

sc_check()

int crypto::sc_check

(

const unsigned char *

)

sc_isnonzero()

int crypto::sc_isnonzero

(

const unsigned char *

)

sc_mul()

void crypto::sc_mul	(	unsigned char *	,
		const unsigned char *	,
		const unsigned char *
	)

sc_muladd()

void crypto::sc_muladd	(	unsigned char *	s,
		const unsigned char *	a,
		const unsigned char *	b,
		const unsigned char *	c
	)

sc_mulsub()

void crypto::sc_mulsub	(	unsigned char *	,
		const unsigned char *	,
		const unsigned char *	,
		const unsigned char *
	)

sc_reduce()

void crypto::sc_reduce

(

unsigned char *

)

sc_reduce32()

void crypto::sc_reduce32

(

unsigned char *

)

sc_sub()

void crypto::sc_sub	(	unsigned char *	,
		const unsigned char *	,
		const unsigned char *
	)

secret_key_to_public_key()

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

inline

sign_message()

std::string crypto::sign_message ( const std::string &  message, const std::string &  privateKey  )

inline

tree_hash() [1/2]

void crypto::tree_hash ( const hash *  hashes, std::size_t  count, hash &  root_hash  )

inline

tree_hash() [2/2]

void crypto::tree_hash	(	const char(*)	hashes[HASH_SIZE],
		size_t	count,
		char *	root_hash
	)

verify_signature() [1/2]

bool crypto::verify_signature ( const std::string &  message, const std::string &  publicKey, const std::string &  signature  )

inline

verify_signature() [2/2]

bool crypto::verify_signature ( const std::string &  message, std::vector< std::string >  publicKey, const std::string &  signature  )

inline

Variable Documentation

column_vectors

std::vector<secret_keyV> crypto::column_vectors

ec_point

POD_CLASS crypto::ec_point

Initial value:

{
    char data[32]

ec_scalar

POD_CLASS crypto::ec_scalar

Initial value:

{
    char data[32]

fe_d

const fe crypto::fe_d

fe_d2

const fe crypto::fe_d2

fe_fffb1

const fe crypto::fe_fffb1

fe_fffb2

const fe crypto::fe_fffb2

fe_fffb3

const fe crypto::fe_fffb3

fe_fffb4

const fe crypto::fe_fffb4

fe_ma

const fe crypto::fe_ma

fe_ma2

const fe crypto::fe_ma2

fe_sqrtm1

const fe crypto::fe_sqrtm1

ge_base

const ge_precomp crypto::ge_base[32][8]

ge_Bi

const ge_precomp crypto::ge_Bi[8]

ge_p3_H

const ge_p3 crypto::ge_p3_H

ge_p3_identity

const ge_p3 crypto::ge_p3_identity

hash

POD_CLASS crypto::hash

Initial value:

{
    char data[HASH_SIZE]

hash64

POD_CLASS crypto::hash64

Initial value:

{
    char data[64]

hash8

POD_CLASS crypto::hash8

Initial value:

{
    char data[8]

key_derivation

POD_CLASS crypto::key_derivation

key_image

POD_CLASS crypto::key_image

null_hash

const crypto::hash crypto::null_hash = boost::value_initialized<crypto::hash>()

static

null_hash64

const crypto::hash64 crypto::null_hash64 = boost::value_initialized<crypto::hash64>()

static

null_hash8

const crypto::hash8 crypto::null_hash8 = boost::value_initialized<crypto::hash8>()

static

null_pkey

const crypto::public_key crypto::null_pkey = crypto::public_key{}

null_skey

const crypto::secret_key crypto::null_skey = crypto::secret_key{}

public_key

POD_CLASS crypto::public_key

public_keyM

POD_CLASS crypto::public_keyM

Initial value:

{
    int cols

public_keyV

POD_CLASS crypto::public_keyV

Initial value:

{
    std::vector<public_key> keys

PUSH_WARNINGS

crypto::PUSH_WARNINGS

rows

int crypto::rows

secret_keyV

POD_CLASS crypto::secret_keyV

Initial value:

{
    std::vector<secret_key> keys

signature

POD_CLASS crypto::signature

Initial value:

{
    ec_scalar c, r