fix uninitialized variables in ecc::compact_signature (fc::array) and a few other places

include/fc/array.hpp

@@ -29,6 +29,56 @@ namespace fc {
     T data[N];
   };
 
+  /** provided for default 0 init */
+  template<size_t N>
+  class array<unsigned char,N>
+  {
+    public:
+    typedef unsigned char T;
+    array(){ memset( data, 0, sizeof(data) ); }
+    /**
+     *  Checked indexing (when in debug build) that also simplifies dereferencing
+     *  when you have an array<T,N>*.    
+     */
+    ///@{
+    T&       at( size_t pos )      { assert( pos < N); return data[pos]; }
+    const T& at( size_t pos )const { assert( pos < N); return data[pos]; }
+    ///@}
+    
+    T*           begin()       {  return &data[0]; }
+    const T*     begin()const  {  return &data[0]; }
+    const T*     end()const    {  return &data[N]; }
+
+    size_t       size()const { return N; }
+    
+    T data[N];
+  };
+
+  /** provided for default 0 init */
+  template<size_t N>
+  class array<char,N>
+  {
+    public:
+    typedef char T;
+    array(){ memset( data, 0, sizeof(data) ); }
+    /**
+     *  Checked indexing (when in debug build) that also simplifies dereferencing
+     *  when you have an array<T,N>*.    
+     */
+    ///@{
+    T&       at( size_t pos )      { assert( pos < N); return data[pos]; }
+    const T& at( size_t pos )const { assert( pos < N); return data[pos]; }
+    ///@}
+    
+    T*           begin()       {  return &data[0]; }
+    const T*     begin()const  {  return &data[0]; }
+    const T*     end()const    {  return &data[N]; }
+
+    size_t       size()const { return N; }
+    
+    T data[N];
+  };
+
   template<typename T, size_t N>
   bool operator == ( const array<T,N>& a, const array<T,N>& b )
   { return 0 == memcmp( a.data, b.data, N*sizeof(T) ); }

include/fc/crypto/elliptic.hpp

@@ -121,6 +121,7 @@ namespace fc {
       {
           fc::raw::pack( s, pk.get_secret() );
       }
+
   } // namespace raw
 
 } // namespace fc 

src/crypto/elliptic.cpp

@@ -25,6 +25,7 @@ struct ssl_wrapper
     {
         return obj;
     }
+    ssl_type* operator->() { return obj; }
 
     ssl_type* obj;
 };
@@ -54,6 +55,7 @@ struct ssl_bignum
 
     SSL_TYPE(ec_group, EC_GROUP, EC_GROUP_free)
     SSL_TYPE(ec_point, EC_POINT, EC_POINT_free)
+    SSL_TYPE(ecdsa_sig, ECDSA_SIG, ECDSA_SIG_free)
     SSL_TYPE(bn_ctx, BN_CTX, BN_CTX_free)
 
     namespace detail 
@@ -456,20 +458,23 @@ struct ssl_bignum
 
     compact_signature private_key::sign_compact( const fc::sha256& digest )const
     {
+       try {
         FC_ASSERT( my->_key != nullptr );
-        ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);
+        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);
+        ecdsa_sig sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);
 
-        if (sig==NULL) 
+        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;
-            auto my_pub_key = get_public_key().serialize();
             for (int i=0; i<4; i++)
             {
                 public_key keyRec;
@@ -487,14 +492,30 @@ struct ssl_bignum
             }
 
             if (nRecId == -1)
-            FC_THROW_EXCEPTION( exception, "unable to construct recoverable key");
+            {
+              FC_THROW_EXCEPTION( exception, "unable to construct recoverable key");
+            }
             
             csig.data[0] = nRecId+27+4;//(fCompressedPubKey ? 4 : 0);
             BN_bn2bin(sig->r,&csig.data[33-(nBitsR+7)/8]);
             BN_bn2bin(sig->s,&csig.data[65-(nBitsS+7)/8]);
+
+            /*try {
+            auto pubk = public_key( csig, digest ).serialize();
+            FC_ASSERT( pubk == my_pub_key, "", ("pubk",pubk)("my_pub_key",my_pub_key)("private_key", *this) );
+            } catch ( fc::exception& e)
+            {
+              wlog( "${e}", ("e", e.to_detail_string() ) );
+              csig = sign_compact( digest );
+              elog( "it worked the second time!" );
+              exit(1);
+            }
+            */
         }
-        ECDSA_SIG_free(sig);
+        // TODO: memory leak if exception thrown!
+        //ECDSA_SIG_free(sig);
         return csig;
+      } FC_RETHROW_EXCEPTIONS( warn, "sign ${digest}", ("digest", digest)("private_key",*this) );
     }
 
    private_key& private_key::operator=( private_key&& pk )

src/log/logger.cpp

@@ -13,7 +13,7 @@ namespace fc {
     class logger::impl : public fc::retainable {
       public:
          impl()
-         :_parent(nullptr),_enabled(true),_level(log_level::warn){}
+         :_parent(nullptr),_enabled(true),_additivity(false),_level(log_level::warn){}
          fc::string       _name;
          logger           _parent;
          bool             _enabled;

src/uint128.cpp

@@ -71,7 +71,7 @@ namespace fc
           }
 
           while(i != sz.end()) {
-            unsigned int n;
+            unsigned int n = 0;
             const char ch = *i;
 
             if(ch >= 'A' && ch <= 'Z') {