Updating crypto functions.

include/fc/crypto/elliptic.hpp

@@ -31,6 +31,7 @@ namespace fc {
            public_key( const compact_signature& c, const fc::sha256& digest );
 
            bool valid()const;
+           public_key mult( const fc::sha256& digest );
 
            public_key( public_key&& pk );
            public_key& operator=( public_key&& pk );
@@ -65,7 +66,7 @@ namespace fc {
            fc::sha512 get_shared_secret( const public_key& pub );
 
            signature         sign( const fc::sha256& digest );
-           compact_signature sign_compact( const fc::sha256& digest );
+           compact_signature sign_compact( const fc::sha256& digest )const;
            bool              verify( const fc::sha256& digest, const signature& sig );
 
            public_key get_public_key()const;

include/fc/crypto/sha1.hpp

@@ -69,3 +69,17 @@ class sha1
   void from_variant( const variant& v, sha1& bi );
 
 } // namespace fc
+
+namespace std
+{
+    template<typename T> struct hash;
+
+    template<>
+    struct hash<fc::sha1>
+    {
+       size_t operator()( const fc::sha1& s )const
+       {
+           return  *((size_t*)&s);
+       }
+    };
+}

include/fc/crypto/sha224.hpp

@@ -71,3 +71,16 @@ class sha224
   void from_variant( const variant& v, sha224& bi );
 
 } // fc
+namespace std
+{
+    template<typename T> struct hash;
+
+    template<>
+    struct hash<fc::sha224>
+    {
+       size_t operator()( const fc::sha224& s )const
+       {
+           return  *((size_t*)&s);
+       }
+    };
+}

include/fc/reflect/reflect.hpp

@@ -13,6 +13,7 @@
 #include <boost/preprocessor/seq/seq.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <stdint.h>
+#include <string.h>
 
 #include <fc/reflect/typename.hpp>
 

include/fc/variant.hpp

@@ -4,6 +4,7 @@
 #include <fc/string.hpp>
 #include <memory>
 #include <string.h> // memset
+#include <unordered_set>
 
 namespace fc
 {
@@ -38,6 +39,12 @@ namespace fc
    void from_variant( const variant& var,  mutable_variant_object& vo );
    void to_variant( const std::vector<char>& var,  variant& vo );
    void from_variant( const variant& var,  std::vector<char>& vo );
+
+   template<typename T>
+   void to_variant( const std::unordered_set<T>& var,  variant& vo );
+   template<typename T>
+   void from_variant( const variant& var,  std::unordered_set<T>& vo );
+
    void to_variant( const time_point& var,  variant& vo );
    void from_variant( const variant& var,  time_point& vo );
    #ifdef __APPLE__
@@ -244,6 +251,24 @@ namespace fc
           from_variant( var, *vo );
       }
    }
+   template<typename T>
+   void to_variant( const std::unordered_set<T>& var,  variant& vo )
+   {
+       std::vector<variant> vars(var.size());
+       size_t i = 0;
+       for( auto itr = var.begin(); itr != var.end(); ++itr )
+          vars[i] = variant(*itr);
+       vo = vars;
+   }
+   template<typename T>
+   void from_variant( const variant& var,  std::unordered_set<T>& vo )
+   {
+      const variants& vars = var.get_array();
+      vo.clear();
+      vo.reserve( vars.size() );
+      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
+         vo.insert( itr->as<T>() );
+   }
 
    /** @ingroup Serializable */
    template<typename T>

src/crypto/elliptic.cpp

@@ -11,6 +11,50 @@
 #include <assert.h>
 
 namespace fc { namespace ecc {
+
+template <typename ssl_type>
+struct ssl_wrapper
+{
+    ssl_wrapper(ssl_type* obj)
+      : obj(obj) {}
+    virtual ~ssl_wrapper()
+    {
+    }
+    operator ssl_type*()
+    {
+        return obj;
+    }
+
+    ssl_type* obj;
+};
+
+struct ssl_bignum
+  : public ssl_wrapper<BIGNUM>
+{
+    ssl_bignum()
+      : ssl_wrapper(BN_new()) {}
+    ~ssl_bignum()
+    {
+        BN_free(obj);
+    }
+};
+
+    #define SSL_TYPE(name, ssl_type, free_func) \
+        struct name \
+          : public ssl_wrapper<ssl_type> \
+        { \
+            name(ssl_type* obj) \
+              : ssl_wrapper(obj) {} \
+            ~name() \
+            { \
+                free_func(obj); \
+            } \
+        };
+
+    SSL_TYPE(ec_group, EC_GROUP, EC_GROUP_free)
+    SSL_TYPE(ec_point, EC_POINT, EC_POINT_free)
+    SSL_TYPE(bn_ctx, BN_CTX, BN_CTX_free)
+
     namespace detail 
     { 
       class public_key_impl
@@ -188,6 +232,30 @@ namespace fc { namespace ecc {
     }
     */
 
+    public_key public_key::mult( const fc::sha256& digest )
+    {
+        // 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_secp256k1));
+
+        ssl_bignum z;
+        BN_bin2bn((unsigned char*)&digest, sizeof(digest), z);
+
+        // multiply by digest
+        ssl_bignum one;
+        bn_ctx ctx(BN_CTX_new());
+        BN_one(one);
+
+        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_secp256k1 );
+        EC_KEY_set_public_key(rtn.my->_key,result);
+
+        return rtn;
+    }
+
     private_key::private_key()
     {}
 
@@ -275,7 +343,7 @@ namespace fc { namespace ecc {
     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 );
+      /*size_t nbytes = */i2o_ECPublicKey( my->_key, nullptr );
       assert( nbytes == 33 );
       public_key_data dat;
       char* front = &dat.data[0];
@@ -384,7 +452,7 @@ namespace fc { namespace ecc {
         FC_THROW_EXCEPTION( exception, "unable to reconstruct public key from signature" );
     }
 
-    compact_signature private_key::sign_compact( const fc::sha256& digest )
+    compact_signature private_key::sign_compact( const fc::sha256& digest )const
     {
         ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);