Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

bug fixes

Browse source
This commit is contained in:
Daniel Larimer 2013-06-06 20:37:04 -04:00
parent 0fd0574c05
commit 6563c12f88
3 changed files with 185 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -108,6 +108,7 @@ set( fc_sources
src/crypto/sha512.cpp
src/crypto/dh.cpp
src/crypto/blowfish.cpp
src/crypto/elliptic.cpp
src/network/tcp_socket.cpp
src/network/udp_socket.cpp
src/network/http/http_connection.cpp

179
include/fc/crypto/elliptic.hpp
View file

@ -4,96 +4,109 @@
#include <fc/crypto/sha512.hpp>
#include <fc/fwd.hpp>
#include <fc/array.hpp>
#include <vector>
#include <fc/io/raw_fwd.hpp>
namespace fc
{
namespace ecc
{
namespace detail
{
class public_key_impl;
class private_key_impl;
}
typedef fc::array<char,72> signature;
typedef fc::array<unsigned char,65> compact_signature;
class public_key
{
public:
public_key();
~public_key();
bool verify( const fc::sha256& digest, const signature& sig );
std::vector<char> serialize()const;
public_key( const std::vector<char>& v );
public_key( const compact_signature& c, const fc::sha256& digest );
private:
friend class private_key;
fc::fwd<detail::public_key_impl,8> my;
};
class private_key
{
public:
private_key();
private_key( std::vector<char> k );
~private_key();
static private_key generate();
static private_key regenerate( const fc::sha256& secret );
fc::sha256 get_secret()const; // get the private key secret
/**
* Given a public key, calculatse a 512 bit shared secret between that
* key and this private key.
*/
fc::sha512 get_shared_secret( const public_key& pub );
signature sign( const fc::sha256& digest );
compact_signature sign_compact( const fc::sha256& digest );
bool verify( const fc::sha256& digest, const signature& sig );
public_key get_public_key()const;
private:
fc::fwd<detail::private_key_impl,8> my;
};
} // namespace ecc
namespace fc {
namespace ecc {
namespace detail
{
class public_key_impl;
class private_key_impl;
}
typedef fc::array<char,33> public_key_data;
typedef fc::array<char,72> signature;
typedef fc::array<unsigned char,65> compact_signature;
class public_key
{
public:
public_key();
public_key(const public_key& k);
~public_key();
bool verify( const fc::sha256& digest, const signature& sig );
public_key_data serialize()const;
public_key( const public_key_data& v );
public_key( const compact_signature& c, const fc::sha256& digest );
bool valid()const;
public_key( public_key&& pk );
public_key& operator=( public_key&& pk );
public_key& operator=( const public_key& pk );
private:
friend class private_key;
fc::fwd<detail::public_key_impl,8> my;
};
class private_key
{
public:
private_key();
private_key( std::vector<char> k );
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 );
static private_key generate();
static private_key regenerate( const fc::sha256& secret );
fc::sha256 get_secret()const; // get the private key secret
/**
* Given a public key, calculatse a 512 bit shared secret between that
* key and this private key.
*/
fc::sha512 get_shared_secret( const public_key& pub );
signature sign( const fc::sha256& digest );
compact_signature sign_compact( const fc::sha256& digest );
bool verify( const fc::sha256& digest, const signature& sig );
public_key get_public_key()const;
private:
fc::fwd<detail::private_key_impl,8> my;
};
} // namespace ecc
void to_variant( const ecc::private_key& var, variant& vo );
void from_variant( const variant& var, ecc::private_key& vo );
void to_variant( const ecc::public_key& var, variant& vo );
void from_variant( const variant& var, ecc::public_key& vo );
namespace raw
{
template<typename Stream>
inline void pack( Stream& s, const fc::ecc::public_key& v )
{
pack( s, v.serialize() );
}
template<typename Stream>
inline void unpack( Stream& s, fc::ecc::public_key& v )
{
std::vector<char> d;
unpack( s, d );
v = fc::ecc::public_key( fc::move(d) );
}
template<typename Stream>
void unpack( Stream& s, fc::ecc::public_key& pk)
{
ecc::public_key_data ser;
fc::raw::unpack(s,ser);
pk = fc::ecc::public_key( ser );
}
template<typename Stream>
inline void pack( Stream& s, const fc::ecc::private_key& v )
{
pack( s, v.get_secret() );
}
template<typename Stream>
void pack( Stream& s, const fc::ecc::public_key& pk)
{
fc::raw::pack( s, pk.serialize() );
}
template<typename Stream>
inline void unpack( Stream& s, fc::ecc::private_key& v )
{
fc::sha256 secret;
unpack( s, secret );
v = fc::ecc::private_key::regenerate( secret );
}
template<typename Stream>
void unpack( Stream& s, fc::ecc::private_key& pk)
{
fc::sha256 sec;
unpack( s, sec );
pk = ecc::private_key::regenerate(sec);
}
template<typename Stream>
void pack( Stream& s, const fc::ecc::private_key& pk)
{
fc::raw::pack( s, pk.get_secret() );
}
} // namespace raw
} // fc
} // namespace fc

96
src/crypto/elliptic.cpp
View file

@ -272,14 +272,14 @@ namespace fc { namespace ecc {
return 1 == ECDSA_verify( 0, (unsigned char*)&digest, sizeof(digest), (unsigned char*)&sig, sizeof(sig), my->_key );
}
std::vector<char> public_key::serialize()const
public_key_data public_key::serialize()const
{
EC_KEY_set_conv_form( my->_key, POINT_CONVERSION_COMPRESSED );
size_t nbytes = i2o_ECPublicKey( my->_key, nullptr );
std::vector<char> dat(nbytes);
char* front = &dat[0];
assert( nbytes == 33 );
public_key_data dat;
char* front = &dat.data[0];
i2o_ECPublicKey( my->_key, (unsigned char**)&front );
fprintf( stderr, "public key size: %lu\n", nbytes );
return dat;
/*
EC_POINT* pub = EC_KEY_get0_public_key( my->_key );
@ -293,11 +293,11 @@ namespace fc { namespace ecc {
public_key::~public_key()
{
}
public_key::public_key( const std::vector<char>& v )
public_key::public_key( const public_key_data& dat )
{
const char* front = &v[0];
const char* front = &dat.data[0];
my->_key = EC_KEY_new_by_curve_name( NID_secp256k1 );
my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, v.size() );
my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, sizeof(public_key_data) );
if( !my->_key )
{
fprintf( stderr, "decode error occurred??" );
@ -426,4 +426,84 @@ namespace fc { namespace ecc {
return csig;
}
} }
private_key& private_key::operator=( private_key&& pk )
{
if( my->_key )
{
EC_KEY_free(my->_key);
}
my->_key = pk.my->_key;
pk.my->_key = nullptr;
return *this;
}
public_key::public_key( const public_key& pk )
:my(pk.my)
{
}
public_key::public_key( public_key&& pk )
:my( fc::move( pk.my) )
{
}
private_key::private_key( const private_key& pk )
:my(pk.my)
{
}
private_key::private_key( private_key&& pk )
:my( fc::move( pk.my) )
{
}
public_key& public_key::operator=( public_key&& pk )
{
if( my->_key )
{
EC_KEY_free(my->_key);
}
my->_key = pk.my->_key;
pk.my->_key = nullptr;
return *this;
}
public_key& public_key::operator=( const public_key& pk )
{
if( my->_key )
{
EC_KEY_free(my->_key);
}
my->_key = EC_KEY_dup(pk.my->_key);
return *this;
}
private_key& private_key::operator=( const private_key& pk )
{
if( my->_key )
{
EC_KEY_free(my->_key);
}
my->_key = EC_KEY_dup(pk.my->_key);
return *this;
}
}
void to_variant( const ecc::private_key& var, variant& vo )
{
vo = var.get_secret();
}
void from_variant( const variant& var, ecc::private_key& vo )
{
fc::sha256 sec;
from_variant( var, sec );
vo = ecc::private_key::regenerate(sec);
}
void to_variant( const ecc::public_key& var, variant& vo )
{
vo = var.serialize();
}
void from_variant( const variant& var, ecc::public_key& vo )
{
ecc::public_key_data dat;
from_variant( var, dat );
vo = ecc::public_key(dat);
}
}