fc::crypto::r1::public_key Class Reference

contains only the public point of an elliptic curve key. More...

#include <elliptic_r1.hpp>

Public Member Functions
	public_key ()
	public_key (const public_key &k)
	~public_key ()
bool	verify (const fc::sha256 &digest, const signature &sig)
public_key_data	serialize () const
	operator public_key_data () const
	public_key (const public_key_data &v)
	public_key (const public_key_point_data &v)
	public_key (const compact_signature &c, const fc::sha256 &digest, bool check_canonical=true)
bool	valid () const
public_key	mult (const fc::sha256 &offset)
public_key	add (const fc::sha256 &offset) const
	public_key (public_key &&pk)
public_key &	operator= (public_key &&pk)
public_key &	operator= (const public_key &pk)
std::string	to_base58 () const
	Allows to convert current public key object into base58 number.

Static Public Member Functions
static public_key	from_base58 (const std::string &b58)

Friends
class	private_key
bool	operator== (const public_key &a, const public_key &b)
bool	operator!= (const public_key &a, const public_key &b)
compact_signature	signature_from_ecdsa (const EC_KEY *key, const public_key_data &pub_data, fc::ecdsa_sig &sig, const fc::sha256 &d)

Detailed Description

Definition at line 32 of file elliptic_r1.hpp.

Constructor & Destructor Documentation

public_key() [1/6]

fc::crypto::r1::public_key::public_key

(

)

Definition at line 455 of file elliptic_r1.cpp.

    {
    }

Here is the caller graph for this function:

public_key() [2/6]

fc::crypto::r1::public_key::public_key

(

const public_key &

k

)

Definition at line 573 of file elliptic_r1.cpp.

   :my(pk.my)
   {
   }

~public_key()

fc::crypto::r1::public_key::~public_key

(

)

Definition at line 458 of file elliptic_r1.cpp.

    {
    }

public_key() [3/6]

fc::crypto::r1::public_key::public_key

(

const public_key_data &

v

)

Definition at line 474 of file elliptic_r1.cpp.

    {
      const char* front = &dat.data[0];
      if( *front == 0 ){}
      else
      {
         my->_key = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
         my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, sizeof(public_key_data) );
         if( !my->_key )
         {
           FC_THROW_EXCEPTION( exception, "error decoding public key", ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
         }
      }
    }

public_key() [4/6]

fc::crypto::r1::public_key::public_key

(

const public_key_point_data &

v

)

Definition at line 461 of file elliptic_r1.cpp.

    {
      const char* front = &dat.data[0];
      if( *front == 0 ){}
      else
      {
         my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, sizeof(dat)  );
         if( !my->_key )
         {
           FC_THROW_EXCEPTION( exception, "error decoding public key", ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
         }
      }
    }

public_key() [5/6]

fc::crypto::r1::public_key::public_key	(	const compact_signature &	c,
		const fc::sha256 &	digest,
		bool	check_canonical = true )

Definition at line 516 of file elliptic_r1.cpp.

    {
        int nV = c.data[0];
        if (nV<27 || nV>=35)
            FC_THROW_EXCEPTION( exception, "unable to reconstruct public key from signature" );
 
        ecdsa_sig sig = ECDSA_SIG_new();
        BIGNUM *r = BN_new(), *s = BN_new();
        BN_bin2bn(&c.data[1],32,r);
        BN_bin2bn(&c.data[33],32,s);
        ECDSA_SIG_set0(sig, r, s);
 
        my->_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
 
        const EC_GROUP* group = EC_KEY_get0_group(my->_key);
        ssl_bignum order, halforder;
        EC_GROUP_get_order(group, order, nullptr);
        BN_rshift1(halforder, order);
        if(BN_cmp(s, halforder) > 0)
           FC_THROW_EXCEPTION( exception, "invalid high s-value encountered in r1 signature" );
 
        if (nV >= 31)
        {
            EC_KEY_set_conv_form( my->_key, POINT_CONVERSION_COMPRESSED );
            nV -= 4;
//            fprintf( stderr, "compressed\n" );
        }
 
        if (ECDSA_SIG_recover_key_GFp(my->_key, sig, (unsigned char*)&digest, sizeof(digest), nV - 27, 0) == 1)
            return;
        FC_THROW_EXCEPTION( exception, "unable to reconstruct public key from signature" );
    }

Here is the call graph for this function:

public_key() [6/6]

fc::crypto::r1::public_key::public_key

(

public_key &&

pk

)

Definition at line 577 of file elliptic_r1.cpp.

   :my( fc::move( pk.my) )
   {
   }

Member Function Documentation

add()

public_key fc::crypto::r1::public_key::add

(

const fc::sha256 &

offset

)

const

Definition at line 193 of file elliptic_em_impl_pub.cpp.

    {
      try {
        ec_group group(EC_GROUP_new_by_curve_name(NID_secp256k1));
        bn_ctx ctx(BN_CTX_new());
 
        fc::bigint digest_bi( (char*)&digest, sizeof(digest) );
 
        ssl_bignum order;
        EC_GROUP_get_order(group, order, ctx);
        if( digest_bi > fc::bigint(order) )
        {
          FC_THROW_EXCEPTION( exception, "digest > group order" );
        }
 
 
        public_key digest_key = private_key::regenerate(digest).get_public_key();
        const EC_POINT* digest_point   = EC_KEY_get0_public_key( digest_key.my->_key );
 
        // get point from this public key
        const EC_POINT* master_pub   = EC_KEY_get0_public_key( my->_key );
 
//        ssl_bignum z;
//        BN_bin2bn((unsigned char*)&digest, sizeof(digest), z);
 
        // multiply by digest
//        ssl_bignum one;
//        BN_one(one);
 
        ec_point result(EC_POINT_new(group));
        EC_POINT_add(group, result, digest_point, master_pub, ctx);
 
        if (EC_POINT_is_at_infinity(group, result))
        {
          FC_THROW_EXCEPTION( exception, "point at  infinity" );
        }
 
 
        public_key rtn;
        rtn.my->_key = EC_KEY_new_by_curve_name( NID_secp256k1 );
        EC_KEY_set_public_key(rtn.my->_key,result);
        return rtn;
      } FC_RETHROW_EXCEPTIONS( debug, "digest: ${digest}", ("digest",digest) );
    }

Here is the call graph for this function:

from_base58()

public_key fc::crypto::r1::public_key::from_base58 ( const std::string & b58 )

static

Definition at line 318 of file elliptic_r1.cpp.

    {
        array<char, 37> data;
        size_t s = fc::from_base58(b58, (char*)&data, sizeof(data) );
        FC_ASSERT( s == sizeof(data) );
 
        public_key_data key;
        uint32_t check = (uint32_t)sha256::hash(data.data, sizeof(key))._hash[0];
        FC_ASSERT( memcmp( (char*)&check, data.data + sizeof(key), sizeof(check) ) == 0 );
        memcpy( (char*)key.data, data.data, sizeof(key) );
        return public_key(key);
    }

Here is the call graph for this function:

mult()

public_key fc::crypto::r1::public_key::mult

(

const fc::sha256 &

offset

)

Definition at line 235 of file elliptic_r1.cpp.

    {
        // get point from this public key
        const EC_POINT* master_pub   = EC_KEY_get0_public_key( my->_key );
        ec_group group(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
 
        ssl_bignum z;
        BN_bin2bn((unsigned char*)&digest, sizeof(digest), z);
 
        // multiply by digest
        ssl_bignum one;
        BN_one(one);
        bn_ctx ctx(BN_CTX_new());
 
        ec_point result(EC_POINT_new(group));
        EC_POINT_mul(group, result, z, master_pub, one, ctx);
 
        public_key rtn;
        rtn.my->_key = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
        EC_KEY_set_public_key(rtn.my->_key,result);
 
        return rtn;
    }

Here is the call graph for this function:

operator public_key_data()

fc::crypto::r1::public_key::operator public_key_data ( ) const

inline

Definition at line 41 of file elliptic_r1.hpp.

{ return serialize(); }

Here is the call graph for this function:

operator=() [1/2]

public_key & fc::crypto::r1::public_key::operator=

(

const public_key &

pk

)

Definition at line 600 of file elliptic_r1.cpp.

   {
     if( my->_key )
     {
       EC_KEY_free(my->_key);
     }
     my->_key = EC_KEY_dup(pk.my->_key);
     return *this;
   }

operator=() [2/2]

public_key & fc::crypto::r1::public_key::operator=

(

public_key &&

pk

)

Definition at line 590 of file elliptic_r1.cpp.

   {
     if( my->_key )
     {
       EC_KEY_free(my->_key);
     }
     my->_key = pk.my->_key;
     pk.my->_key = nullptr;
     return *this;
   }

serialize()

public_key_data fc::crypto::r1::public_key::serialize

(

)

const

Definition at line 438 of file elliptic_r1.cpp.

    {
      public_key_data dat;
      if( !my->_key ) return dat;
      EC_KEY_set_conv_form( my->_key, POINT_CONVERSION_COMPRESSED );
      /*size_t nbytes = i2o_ECPublicKey( my->_key, nullptr ); */
      /*FC_ASSERT( nbytes == 33 )*/
      char* front = &dat.data[0];
      i2o_ECPublicKey( my->_key, (unsigned char**)&front  );
      return dat;
      /*
       EC_POINT* pub   = EC_KEY_get0_public_key( my->_key );
       EC_GROUP* group = EC_KEY_get0_group( my->_key );
       EC_POINT_get_affine_coordinates_GFp( group, pub, self.my->_pub_x.get(), self.my->_pub_y.get(), nullptr );
       */
    }

Here is the caller graph for this function:

to_base58()

std::string fc::crypto::r1::public_key::to_base58

(

)

const

Definition at line 307 of file elliptic_r1.cpp.

    {
      public_key_data key = serialize();
      uint32_t check = (uint32_t)sha256::hash(key.data, sizeof(key))._hash[0];
      static_assert(sizeof(key) + sizeof(check) == 37, ""); // hack around gcc bug: key.size() should be constexpr, but isn't
      array<char, 37> data;
      memcpy(data.data, key.begin(), key.size());
      memcpy(data.begin() + key.size(), (const char*)&check, sizeof(check));
      return fc::to_base58(data.begin(), data.size(), fc::yield_function_t());
    }

Here is the call graph for this function:

valid()

bool fc::crypto::r1::public_key::valid

(

)

const

Definition at line 258 of file elliptic_r1.cpp.

    {
      return my->_key != nullptr;
    }

Here is the caller graph for this function:

verify()

bool fc::crypto::r1::public_key::verify	(	const fc::sha256 &	digest,
		const signature &	sig )

Definition at line 433 of file elliptic_r1.cpp.

    {
      return 1 == ECDSA_verify( 0, (unsigned char*)&digest, sizeof(digest), (unsigned char*)&sig, sizeof(sig), my->_key );
    }

Here is the call graph for this function:

Friends And Related Symbol Documentation

operator!=

bool operator!= ( const public_key & a, const public_key & b )

friend

Definition at line 60 of file elliptic_r1.hpp.

           {
            return a.serialize() != b.serialize();
           }

operator==

bool operator== ( const public_key & a, const public_key & b )

friend

Definition at line 56 of file elliptic_r1.hpp.

           {
            return a.serialize() == b.serialize();
           }

private_key

friend class private_key

friend

Definition at line 70 of file elliptic_r1.hpp.

signature_from_ecdsa

compact_signature signature_from_ecdsa ( const EC_KEY * key, const public_key_data & pub_data, fc::ecdsa_sig & sig, const fc::sha256 & d )

friend

Definition at line 136 of file elliptic_r1.cpp.

                                                                                                                                    {
        //We can't use ssl_bignum here; _get0() does not transfer ownership to us; _set0() does transfer ownership to fc::ecdsa_sig
        const BIGNUM *sig_r, *sig_s;
        BIGNUM *r = BN_new(), *s = BN_new();
        ECDSA_SIG_get0(sig, &sig_r, &sig_s);
        BN_copy(r, sig_r);
        BN_copy(s, sig_s);
 
        //want to always use the low S value
        const EC_GROUP* group = EC_KEY_get0_group(key);
        ssl_bignum order, halforder;
        EC_GROUP_get_order(group, order, nullptr);
        BN_rshift1(halforder, order);
        if(BN_cmp(s, halforder) > 0)
           BN_sub(s, order, s);
 
        compact_signature csig;
 
        int nBitsR = BN_num_bits(r);
        int nBitsS = BN_num_bits(s);
        if(nBitsR > 256 || nBitsS > 256)
          FC_THROW_EXCEPTION( exception, "Unable to sign" );
 
        ECDSA_SIG_set0(sig, r, s);
 
        int nRecId = -1;
        for (int i=0; i<4; i++)
        {
          public_key keyRec;
          keyRec.my->_key = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
          if (ECDSA_SIG_recover_key_GFp(keyRec.my->_key, sig, (unsigned char*)&d, sizeof(d), i, 1) == 1)
          {
            if (keyRec.serialize() == pub_data )
            {
              nRecId = i;
              break;
            }
          }
        }
        if (nRecId == -1)
          FC_THROW_EXCEPTION( exception, "unable to construct recoverable key");
 
        csig.data[0] = nRecId+27+4;
        BN_bn2bin(r,&csig.data[33-(nBitsR+7)/8]);
        BN_bn2bin(s,&csig.data[65-(nBitsS+7)/8]);
 
        return csig;
    }

---

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

• libraries/fc/include/fc/crypto/elliptic_r1.hpp
• libraries/fc/src/crypto/elliptic_em_impl_pub.cpp
• libraries/fc/src/crypto/elliptic_impl_pub.cpp
• libraries/fc/src/crypto/elliptic_r1.cpp