fc::crypto Namespace Reference

Namespaces
namespace	config
namespace	r1
namespace	webauthn

Classes
struct	base58_str_parser
struct	base58_str_parser< std::variant< Ts... >, Prefixes >
struct	base58_str_parser_impl
struct	base58_str_parser_impl< Result, Prefixes, Position >
struct	base58_str_parser_impl< Result, Prefixes, Position, KeyType, Rem... >
struct	base58str_visitor
struct	checksummed_data
struct	eq_comparator
struct	eq_comparator< std::variant< Ts... > >
struct	eq_comparator< webauthn::public_key >
struct	eq_comparator< webauthn::signature >
struct	generate_shared_secret_visitor
struct	hash_visitor
struct	is_valid_visitor
struct	less_comparator
struct	less_comparator< std::variant< Ts... > >
struct	less_comparator< webauthn::public_key >
struct	less_comparator< webauthn::signature >
struct	overloaded
class	private_key
class	public_key
struct	public_key_visitor
struct	recovery_visitor
struct	shim
struct	sign_visitor
class	signature

Functions
bool	prefix_matches (const char *prefix, const std::string &str)
size_t	hash_value (const signature &b)
template<typename Data >
string	to_wif (const Data &secret, const fc::yield_function_t &yield)
template<typename Data >
Data	from_wif (const string &wif_key)
std::ostream &	operator<< (std::ostream &s, const private_key &k)
bool	operator== (const private_key &p1, const private_key &p2)
bool	operator< (const private_key &p1, const private_key &p2)
std::ostream &	operator<< (std::ostream &s, const public_key &k)
bool	operator== (const public_key &p1, const public_key &p2)
bool	operator!= (const public_key &p1, const public_key &p2)
bool	operator< (const public_key &p1, const public_key &p2)
template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >
std::ostream &	operator<< (std::ostream &s, const signature &k)
bool	operator== (const signature &p1, const signature &p2)
bool	operator!= (const signature &p1, const signature &p2)
bool	operator< (const signature &p1, const signature &p2)

Function Documentation

from_wif()

template<typename Data >

Data fc::crypto::from_wif

(

const string &

wif_key

)

Definition at line 77 of file private_key.cpp.

   {
      auto wif_bytes = from_base58(wif_key);
      FC_ASSERT(wif_bytes.size() >= 5);
      auto key_bytes = vector<char>(wif_bytes.begin() + 1, wif_bytes.end() - 4);
      fc::sha256 check = fc::sha256::hash(wif_bytes.data(), wif_bytes.size() - 4);
      fc::sha256 check2 = fc::sha256::hash(check);
 
      FC_ASSERT(memcmp( (char*)&check, wif_bytes.data() + wif_bytes.size() - 4, 4 ) == 0 ||
                memcmp( (char*)&check2, wif_bytes.data() + wif_bytes.size() - 4, 4 ) == 0 );
 
      return Data(fc::variant(key_bytes).as<typename Data::data_type>());
   }

Here is the call graph for this function:

hash_value()

size_t fc::crypto::hash_value

(

const signature &

b

)

Definition at line 81 of file signature.cpp.

                                         {
       return std::visit(hash_visitor(), b._storage);
   }

Here is the caller graph for this function:

operator!=() [1/2]

bool fc::crypto::operator!=	(	const public_key &	p1,
		const public_key &	p2 )

Definition at line 96 of file public_key.cpp.

                                                                  {
      return !(p1 == p2);
   }

operator!=() [2/2]

bool fc::crypto::operator!=	(	const signature &	p1,
		const signature &	p2 )

Definition at line 72 of file signature.cpp.

                                                                {
      return !eq_comparator<signature::storage_type>::apply(p1._storage, p2._storage);
   }

operator<() [1/3]

bool fc::crypto::operator<	(	const private_key &	p1,
		const private_key &	p2 )

Definition at line 136 of file private_key.cpp.

   {
      return less_comparator<private_key::storage_type>::apply(p1._storage, p2._storage);
   }

operator<() [2/3]

bool fc::crypto::operator<	(	const public_key &	p1,
		const public_key &	p2 )

Definition at line 100 of file public_key.cpp.

   {
      return less_comparator<public_key::storage_type>::apply(p1._storage, p2._storage);
   }

operator<() [3/3]

bool fc::crypto::operator<	(	const signature &	p1,
		const signature &	p2 )

Definition at line 76 of file signature.cpp.

   {
      return less_comparator<signature::storage_type>::apply(p1._storage, p2._storage);
   }

operator<<() [1/3]

std::ostream & fc::crypto::operator<<	(	std::ostream &	s,
		const private_key &	k )

Definition at line 127 of file private_key.cpp.

                                                               {
      s << "private_key(" << k.to_string() << ')';
      return s;
   }

Here is the call graph for this function:

operator<<() [2/3]

std::ostream & fc::crypto::operator<<	(	std::ostream &	s,
		const public_key &	k )

Definition at line 87 of file public_key.cpp.

                                                              {
      s << "public_key(" << k.to_string() << ')';
      return s;
   }

operator<<() [3/3]

std::ostream & fc::crypto::operator<<	(	std::ostream &	s,
		const signature &	k )

Definition at line 63 of file signature.cpp.

                                                             {
      s << "signature(" << k.to_string() << ')';
      return s;
   }

Here is the call graph for this function:

operator==() [1/3]

bool fc::crypto::operator==	(	const private_key &	p1,
		const private_key &	p2 )

Definition at line 132 of file private_key.cpp.

                                                                    {
      return eq_comparator<private_key::storage_type>::apply(p1._storage, p2._storage);
   }

operator==() [2/3]

bool fc::crypto::operator==	(	const public_key &	p1,
		const public_key &	p2 )

Definition at line 92 of file public_key.cpp.

                                                                  {
      return eq_comparator<public_key::storage_type>::apply(p1._storage, p2._storage);
   }

operator==() [3/3]

bool fc::crypto::operator==	(	const signature &	p1,
		const signature &	p2 )

Definition at line 68 of file signature.cpp.

                                                                {
      return eq_comparator<signature::storage_type>::apply(p1._storage, p2._storage);
   }

overloaded()

template<class... Ts>

fc::crypto::overloaded

(

Ts...

)

-> overloaded< Ts... >

prefix_matches()

bool fc::crypto::prefix_matches ( const char * prefix, const std::string & str )

inline

Definition at line 27 of file common.hpp.

                                                                        {
      auto prefix_len = const_strlen(prefix);
      return str.size() > prefix_len && str.substr(0, prefix_len).compare(prefix) == 0;
   }

Here is the call graph for this function:

to_wif()

template<typename Data >

string fc::crypto::to_wif	(	const Data &	secret,
		const fc::yield_function_t &	yield )

Definition at line 63 of file private_key.cpp.

   {
      const size_t size_of_data_to_hash = sizeof(typename Data::data_type) + 1;
      const size_t size_of_hash_bytes = 4;
      char data[size_of_data_to_hash + size_of_hash_bytes];
      data[0] = (char)0x80; // this is the Bitcoin MainNet code
      memcpy(&data[1], (const char*)&secret.serialize(), sizeof(typename Data::data_type));
      sha256 digest = sha256::hash(data, size_of_data_to_hash);
      digest = sha256::hash(digest);
      memcpy(data + size_of_data_to_hash, (char*)&digest, size_of_hash_bytes);
      return to_base58(data, sizeof(data), yield);
   }

Here is the call graph for this function:

Here is the caller graph for this function: