fc::crypto::r1::private_key Class Reference

an elliptic curve private key. More...

#include <elliptic_r1.hpp>

Public Member Functions
	private_key ()
	private_key (private_key &&pk)
	private_key (const private_key &pk)
	~private_key ()
private_key &	operator= (private_key &&pk)
private_key &	operator= (const private_key &pk)
private_key_secret	get_secret () const
	operator private_key_secret () const
fc::sha512	get_shared_secret (const public_key &pub) const
signature	sign (const fc::sha256 &digest) const
compact_signature	sign_compact (const fc::sha256 &digest) const
bool	verify (const fc::sha256 &digest, const signature &sig)
public_key	get_public_key () const

Static Public Member Functions
static private_key	generate ()
static private_key	regenerate (const fc::sha256 &secret)
static private_key	generate_from_seed (const fc::sha256 &seed, const fc::sha256 &offset=fc::sha256())

Friends
bool	operator== (const private_key &a, const private_key &b)
bool	operator!= (const private_key &a, const private_key &b)
bool	operator< (const private_key &a, const private_key &b)

Detailed Description

Definition at line 79 of file elliptic_r1.hpp.

Constructor & Destructor Documentation

private_key() [1/3]

fc::crypto::r1::private_key::private_key

(

)

Definition at line 331 of file elliptic_r1.cpp.

    {}

private_key() [2/3]

fc::crypto::r1::private_key::private_key

(

private_key &&

pk

)

Definition at line 585 of file elliptic_r1.cpp.

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

private_key() [3/3]

fc::crypto::r1::private_key::private_key

(

const private_key &

pk

)

Definition at line 581 of file elliptic_r1.cpp.

   :my(pk.my)
   {
   }

~private_key()

fc::crypto::r1::private_key::~private_key

(

)

Definition at line 512 of file elliptic_r1.cpp.

    {
    }

Member Function Documentation

generate()

private_key fc::crypto::r1::private_key::generate ( )

static

Definition at line 391 of file elliptic_r1.cpp.

    {
       private_key self;
       EC_KEY* k = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
       if( !k ) FC_THROW_EXCEPTION( exception, "Unable to generate EC key" );
       self.my->_key = k;
       if( !EC_KEY_generate_key( self.my->_key ) )
       {
          FC_THROW_EXCEPTION( exception, "ecc key generation error" );
 
       }
 
#if 0
          = bigint( EC_KEY_get0_private_key( k );
       EC_POINT* pub   = EC_KEY_get0_public_key( k );
       EC_GROUP* group = EC_KEY_get0_group( k );
 
       EC_POINT_get_affine_coordinates_GFp( group, pub, self.my->_pub_x.get(), self.my->_pub_y.get(), nullptr/*ctx*/ );
 
       EC_KEY_free(k);
#endif
 
       return self;
    }

Here is the caller graph for this function:

generate_from_seed()

private_key fc::crypto::r1::private_key::generate_from_seed ( const fc::sha256 & seed, const fc::sha256 & offset = fc::sha256() )

static

This method of generation enables creating a new private key in a deterministic manner relative to an initial seed. A public_key created from the seed can be multiplied by the offset to calculate the new public key without having to know the private key.

Definition at line 334 of file elliptic_r1.cpp.

    {
        ssl_bignum z;
        BN_bin2bn((unsigned char*)&offset, sizeof(offset), z);
 
        ec_group group(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
        bn_ctx ctx(BN_CTX_new());
        ssl_bignum order;
        EC_GROUP_get_order(group, order, ctx);
 
        // secexp = (seed + z) % order
        ssl_bignum secexp;
        BN_bin2bn((unsigned char*)&seed, sizeof(seed), secexp);
        BN_add(secexp, secexp, z);
        BN_mod(secexp, secexp, order, ctx);
 
        fc::sha256 secret;
        FC_ASSERT(BN_num_bytes(secexp) <= int64_t(sizeof(secret)));
        auto shift = sizeof(secret) - BN_num_bytes(secexp);
        BN_bn2bin(secexp, ((unsigned char*)&secret)+shift);
        return regenerate( secret );
    }

Here is the call graph for this function:

get_public_key()

public_key fc::crypto::r1::private_key::get_public_key

(

)

const

Definition at line 494 of file elliptic_r1.cpp.

    {
       public_key pub;
       pub.my->_key = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
       EC_KEY_set_public_key( pub.my->_key, EC_KEY_get0_public_key( my->_key ) );
       return pub;
    }

Here is the caller graph for this function:

get_secret()

fc::sha256 fc::crypto::r1::private_key::get_secret

(

)

const

Definition at line 373 of file elliptic_r1.cpp.

    {
       if( !my->_key )
       {
          return fc::sha256();
       }
 
       fc::sha256 sec;
       const BIGNUM* bn = EC_KEY_get0_private_key(my->_key);
       if( bn == NULL )
       {
         FC_THROW_EXCEPTION( exception, "get private key failed" );
       }
       int nbytes = BN_num_bytes(bn);
       BN_bn2bin(bn, &((unsigned char*)&sec)[32-nbytes] );
       return sec;
    }

Here is the caller graph for this function:

get_shared_secret()

fc::sha512 fc::crypto::r1::private_key::get_shared_secret

(

const public_key &

pub

)

const

Given a public key, calculatse a 512 bit shared secret between that key and this private key.

Definition at line 503 of file elliptic_r1.cpp.

    {
      FC_ASSERT( my->_key != nullptr );
      FC_ASSERT( other.my->_key != nullptr );
      fc::sha512 buf;
      ECDH_compute_key( (unsigned char*)&buf, sizeof(buf), EC_KEY_get0_public_key(other.my->_key), my->_key, ecies_key_derivation );
      return buf;
    }

Here is the caller graph for this function:

operator private_key_secret()

fc::crypto::r1::private_key::operator private_key_secret ( ) const

inline

Definition at line 102 of file elliptic_r1.hpp.

{ return get_secret(); }

Here is the call graph for this function:

operator=() [1/2]

private_key & fc::crypto::r1::private_key::operator=

(

const private_key &

pk

)

Definition at line 609 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]

private_key & fc::crypto::r1::private_key::operator=

(

private_key &&

pk

)

Definition at line 563 of file elliptic_r1.cpp.

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

regenerate()

private_key fc::crypto::r1::private_key::regenerate ( const fc::sha256 & secret )

static

Definition at line 357 of file elliptic_r1.cpp.

    {
       private_key self;
       self.my->_key = EC_KEY_new_by_curve_name( NID_X9_62_prime256v1 );
       if( !self.my->_key ) FC_THROW_EXCEPTION( exception, "Unable to generate EC key" );
 
       ssl_bignum bn;
       BN_bin2bn( (const unsigned char*)&secret, 32, bn );
 
       if( !EC_KEY_regenerate_key(self.my->_key,bn) )
       {
          FC_THROW_EXCEPTION( exception, "unable to regenerate key" );
       }
       return self;
    }

Here is the caller graph for this function:

sign()

signature fc::crypto::r1::private_key::sign

(

const fc::sha256 &

digest

)

const

Definition at line 416 of file elliptic_r1.cpp.

    {
        unsigned int buf_len = ECDSA_size(my->_key);
//        fprintf( stderr, "%d  %d\n", buf_len, sizeof(sha256) );
        signature sig;
        FC_ASSERT( buf_len == sizeof(sig) );
 
        if( !ECDSA_sign( 0,
                    (const unsigned char*)&digest, sizeof(digest),
                    (unsigned char*)&sig, &buf_len, my->_key ) )
        {
            FC_THROW_EXCEPTION( exception, "signing error" );
        }
 
 
        return sig;
    }

Here is the call graph for this function:

sign_compact()

compact_signature fc::crypto::r1::private_key::sign_compact

(

const fc::sha256 &

digest

)

const

Definition at line 178 of file elliptic_openssl.cpp.

    {
        try {
            FC_ASSERT( my->_key != nullptr );
            auto my_pub_key = get_public_key().serialize(); // just for good measure
            //ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);
            public_key_data key_data;
            while( true )
            {
                ecdsa_sig sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);
 
                if (sig==nullptr)
                    FC_THROW_EXCEPTION( exception, "Unable to sign" );
 
                compact_signature csig;
                // memset( csig.data, 0, sizeof(csig) );
 
                int nBitsR = BN_num_bits(sig->r);
                int nBitsS = BN_num_bits(sig->s);
                if (nBitsR <= 256 && nBitsS <= 256)
                {
                    int nRecId = -1;
                    EC_KEY* key = EC_KEY_new_by_curve_name( NID_secp256k1 );
                    FC_ASSERT( key );
                    EC_KEY_set_conv_form( key, POINT_CONVERSION_COMPRESSED );
                    for (int i=0; i<4; i++)
                    {
                        if (detail::public_key_impl::ECDSA_SIG_recover_key_GFp(key, sig, (unsigned char*)&digest, sizeof(digest), i, 1) == 1)
                        {
                            unsigned char* buffer = (unsigned char*) key_data.begin();
                            i2o_ECPublicKey( key, &buffer ); // FIXME: questionable memory handling
                            if ( key_data == my_pub_key )
                            {
                                nRecId = i;
                                break;
                            }
                        }
                    }
                    EC_KEY_free( key );
 
                    if (nRecId == -1)
                    {
                        FC_THROW_EXCEPTION( exception, "unable to construct recoverable key");
                    }
                    unsigned char* result = nullptr;
                    auto bytes = i2d_ECDSA_SIG( sig, &result );
                    auto lenR = result[3];
                    auto lenS = result[5+lenR];
                    //idump( (result[0])(result[1])(result[2])(result[3])(result[3+lenR])(result[4+lenR])(bytes)(lenR)(lenS) );
                    if( lenR != 32 ) { free(result); continue; }
                    if( lenS != 32 ) { free(result); continue; }
                    //idump( (33-(nBitsR+7)/8) );
                    //idump( (65-(nBitsS+7)/8) );
                    //idump( (sizeof(csig) ) );
                    memcpy( &csig.data[1], &result[4], lenR );
                    memcpy( &csig.data[33], &result[6+lenR], lenS );
                    //idump( (csig.data[33]) );
                    //idump( (csig.data[1]) );
                    free(result);
                    //idump( (nRecId) );
                    csig.data[0] = nRecId+27+4;//(fCompressedPubKey ? 4 : 0);
                    /*
                    idump( (csig) );
                    auto rlen = BN_bn2bin(sig->r,&csig.data[33-(nBitsR+7)/8]);
                    auto slen = BN_bn2bin(sig->s,&csig.data[65-(nBitsS+7)/8]);
                    idump( (rlen)(slen) );
                    */
                }
                return csig;
            } // while true
        } FC_RETHROW_EXCEPTIONS( warn, "sign ${digest}", ("digest", digest)("private_key",*this) );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verify()

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

Definition at line 489 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 private_key & a, const private_key & b )

friend

Definition at line 120 of file elliptic_r1.hpp.

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

operator<

bool operator< ( const private_key & a, const private_key & b )

friend

Definition at line 124 of file elliptic_r1.hpp.

           {
            return a.get_secret() < b.get_secret();
           }

operator==

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

friend

Definition at line 116 of file elliptic_r1.hpp.

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

---

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

• libraries/fc/include/fc/crypto/elliptic_r1.hpp
• libraries/fc/src/crypto/elliptic_openssl.cpp
• libraries/fc/src/crypto/elliptic_r1.cpp