IF: Clean up of bls_private_key, bls_public_key and bls_signature, …

libraries/libfc/include/fc/crypto/bls_private_key.hpp

@@ -5,14 +5,10 @@
 
 namespace fc::crypto::blslib {
 
-   namespace config {
-      constexpr const char* bls_private_key_base_prefix = "PVT";
-      constexpr const char* bls_private_key_prefix = "BLS";
-   };
-
    class bls_private_key
    {
       public:
+
          bls_private_key() = default;
          bls_private_key( bls_private_key&& ) = default;
          bls_private_key( const bls_private_key& ) = default;

libraries/libfc/include/fc/crypto/bls_public_key.hpp

@@ -12,13 +12,6 @@ namespace fc { namespace crypto { namespace blslib {
 
    using namespace std;
 
-   namespace config {
-      constexpr const char* bls_public_key_legacy_prefix = "EOS";
-      constexpr const char* bls_public_key_base_prefix = "PUB";
-      constexpr const char* bls_public_key_prefix = "BLS";
-
-   };
-
    class bls_public_key
    {
       public:
@@ -32,24 +25,8 @@ namespace fc { namespace crypto { namespace blslib {
             _pkey = pkey;
          }
 
-/*         bls_public_key( G1Element pkey ){
-            _pkey = pkey.Serialize();
-         }
-*/
-         //bls_public_key( const bls_signature& c, const sha256& digest, bool check_canonical = true );
-
-/*         bls_public_key( storage_type&& other_storage )
-         :_storage(forward<storage_type>(other_storage))
-         {}
-*/
-         bool valid()const;
-
-         size_t which()const;
-
          // serialize to/from string
          explicit bls_public_key(const string& base58str);
-         //std::string to_string() const;
-         //std::string to_string() ;
 
          std::string to_string(const fc::yield_function_t& yield = fc::yield_function_t()) const;
 
@@ -60,9 +37,6 @@ namespace fc { namespace crypto { namespace blslib {
 
 
          friend std::ostream& operator<< (std::ostream& s, const bls_public_key& k);
-         //friend bool operator == ( const bls_public_key& p1, const bls_public_key& p2);
-         //friend bool operator != ( const bls_public_key& p1, const bls_public_key& p2);
-         //friend bool operator < ( const bls_public_key& p1, const bls_public_key& p2);
          friend struct reflector<bls_public_key>;
          friend class bls_private_key;
    }; // bls_public_key

libraries/libfc/include/fc/crypto/bls_signature.hpp

@@ -42,7 +42,7 @@ namespace fc { namespace crypto { namespace blslib {
 
 //         size_t which() const;
 
-         size_t variable_size() const;
+         //size_t variable_size() const;
 
 
          bls12_381::g2 _sig;
@@ -58,7 +58,7 @@ namespace fc { namespace crypto { namespace blslib {
          //friend bool operator == ( const bls_signature& p1, const bls_signature& p2);
          //friend bool operator != ( const bls_signature& p1, const bls_signature& p2);
         //friend bool operator < ( const bls_signature& p1, const bls_signature& p2);
-         friend std::size_t hash_value(const bls_signature& b); //not cryptographic; for containers
+         //friend std::size_t hash_value(const bls_signature& b); //not cryptographic; for containers
          friend bool operator == ( const bls_signature& p1, const bls_signature& p2);
          friend struct reflector<bls_signature>;
          friend class bls_private_key;

libraries/libfc/src/crypto/bls_private_key.cpp

@@ -25,38 +25,17 @@ namespace fc::crypto::blslib {
       return bls_private_key(v);
    }
 
-   template<typename Data>
-   Data from_wif( const string& wif_key )
+   static vector<uint8_t> priv_parse_base58(const string& base58str)
    {
-   /*   auto wif_bytes = from_base58(wif_key);
-      FC_ASSERT(wif_bytes.size() >= 5);
-      auto key_bytes = vector<char>(wif_bytes.begin() + 1, wif_bytes.end() - 4);
-      fc::sha256 check = fc::sha256::hash(wif_bytes.data(), wif_bytes.size() - 4);
-      fc::sha256 check2 = fc::sha256::hash(check);
+      std::vector<char> v1 = fc::from_base58(base58str);
 
-      FC_ASSERT(memcmp( (char*)&check, wif_bytes.data() + wif_bytes.size() - 4, 4 ) == 0 ||
-                memcmp( (char*)&check2, wif_bytes.data() + wif_bytes.size() - 4, 4 ) == 0 );
+      FC_ASSERT(v1.size() == 32);
 
-      return Data(fc::variant(key_bytes).as<typename Data::data_type>());*/
-   }
+      std::vector<uint8_t> v2(32);
 
-   static vector<uint8_t> priv_parse_base58(const string& base58str)
-   {
-      const auto pivot = base58str.find('_');
-/*
-      if (pivot == std::string::npos) {
-         // wif import
-         using default_type = std::variant_alternative_t<0, bls_private_key::storage_type>;
-         return bls_private_key::storage_type(from_wif<default_type>(base58str));
-      } else {
-         constexpr auto prefix = config::private_key_base_prefix;
-         const auto prefix_str = base58str.substr(0, pivot);
-         FC_ASSERT(prefix == prefix_str, "Private Key has invalid prefix: ${str}", ("str", base58str)("prefix_str", prefix_str));
-
-         auto data_str = base58str.substr(pivot + 1);
-         FC_ASSERT(!data_str.empty(), "Private Key has no data: ${str}", ("str", base58str));
-         return base58_str_parser<bls_private_key::storage_type, config::private_key_prefix>::apply(data_str);
-      }*/
+      std::copy(v1.begin(), v1.end(), v2.begin());
+
+      return v2;
    }
 
    bls_private_key::bls_private_key(const std::string& base58str)
@@ -66,12 +45,13 @@ namespace fc::crypto::blslib {
    std::string bls_private_key::to_string(const fc::yield_function_t& yield) const
    {
 
-      /*PrivateKey pk = AugSchemeMPL().KeyGen(_seed);
+      std::vector<char> v2(32);
+      std::copy(_seed.begin(), _seed.end(), v2.begin());
+
+      std::string data_str = fc::to_base58(v2, yield);
 
-      vector<uint8_t> pkBytes   pk.Serialize()
+      return data_str;
 
-      auto data_str = Util::HexStr(pkBytes);
-      return std::string(config::private_key_base_prefix) + "_" + data_str;*/
    }
 
 } // fc::crypto::blslib

libraries/libfc/src/crypto/bls_public_key.cpp

@@ -4,39 +4,10 @@
 
 namespace fc { namespace crypto { namespace blslib {
 
-  /* struct recovery_visitor : fc::visitor<bls_public_key::storage_type> {
-      recovery_visitor(const sha256& digest, bool check_canonical)
-      :_digest(digest)
-      ,_check_canonical(check_canonical)
-      {}
-
-      template<typename SignatureType>
-      bls_public_key::storage_type operator()(const SignatureType& s) const {
-         return bls_public_key::storage_type(s.recover(_digest, _check_canonical));
-      }
-
-      const sha256& _digest;
-      bool _check_canonical;
-   };
-
-   bls_public_key::bls_public_key( const bls_signature& c, const sha256& digest, bool check_canonical )
-   :_storage(std::visit(recovery_visitor(digest, check_canonical), c._storage))
-   {
-   }
-
-   size_t bls_public_key::which() const {
-      return _storage.index();
-   }*/
-
    static bls12_381::g1 parse_base58(const std::string& base58str)
    {  
 
-      constexpr auto prefix = config::bls_public_key_base_prefix;
-      const auto pivot = base58str.find('_');
-      const auto prefix_str = base58str.substr(0, pivot);
-      auto data_str = base58str.substr(pivot + 1);
-
-      std::vector<char> v1 = fc::from_base58(data_str);
+      std::vector<char> v1 = fc::from_base58(base58str);
 
       FC_ASSERT(v1.size() == 48);
       std::array<uint8_t, 48> v2;
@@ -50,24 +21,17 @@ namespace fc { namespace crypto { namespace blslib {
    :_pkey(parse_base58(base58str))
    {}
 
-
-   bool bls_public_key::valid()const
-   {
-      //return std::visit(is_valid_visitor(), _storage);
-   }
-
-
    std::string bls_public_key::to_string(const fc::yield_function_t& yield)const {
 
       std::vector<char> v2;
       std::array<uint8_t, 48> bytes = _pkey.toCompressedBytesBE();
       std::copy(bytes.begin(), bytes.end(), std::back_inserter(v2));
 
       std::string data_str = fc::to_base58(v2, yield);
-
-      //std::string data_str = Util::HexStr(_pkey);
 
-      return std::string(config::bls_public_key_base_prefix) + "_" + data_str;
+      //return std::string(config::bls_public_key_base_prefix) + "_" + data_str;
+      return data_str;
+
 
    }
 

libraries/libfc/src/crypto/bls_signature.cpp

@@ -4,29 +4,11 @@
 
 namespace fc { namespace crypto { namespace blslib {
 
-   struct hash_visitor : public fc::visitor<size_t> {
-/*      template<typename SigType>
-      size_t operator()(const SigType& sig) const {
-         static_assert(sizeof(sig._data.data) == 65, "sig size is expected to be 65");
-         //signatures are two bignums: r & s. Just add up least significant digits of the two
-         return *(size_t*)&sig._data.data[32-sizeof(size_t)] + *(size_t*)&sig._data.data[64-sizeof(size_t)];
-      }
-
-      size_t operator()(const webauthn::bls_signature& sig) const {
-         return sig.get_hash();
-      }*/
-   };
 
    static bls12_381::g2 sig_parse_base58(const std::string& base58str)
    { try {
 
-
-      const auto pivot = base58str.find('_');
-      auto base_str = base58str.substr(pivot + 1);
-      const auto pivot2 = base_str.find('_');
-      auto data_str = base_str.substr(pivot2 + 1);
-
-      std::vector<char> v1 = fc::from_base58(data_str);
+      std::vector<char> v1 = fc::from_base58(base58str);
 
       FC_ASSERT(v1.size() == 96);
       std::array<uint8_t, 96> v2;
@@ -40,25 +22,6 @@ namespace fc { namespace crypto { namespace blslib {
      :_sig(sig_parse_base58(base58str))
    {}
 
-//   size_t bls_signature::which() const {
-//      //return _storage.index();
-//   }
-
-
-   //template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
-   //template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
-
-   size_t bls_signature::variable_size() const {
-     /* return std::visit(overloaded {
-         [&](const auto& k1r1) {
-            return static_cast<size_t>(0);
-         },
-         [&](const webauthn::bls_signature& wa) {
-            return static_cast<size_t>(wa.variable_size());
-         }
-      }, _storage);*/
-   }
-
    std::string bls_signature::to_string(const fc::yield_function_t& yield) const
    {
 
@@ -68,7 +31,7 @@ namespace fc { namespace crypto { namespace blslib {
 
       std::string data_str = fc::to_base58(v2, yield);
 
-      return std::string(config::bls_signature_base_prefix) + "_" + std::string(config::bls_signature_prefix) + "_" + data_str;
+      return data_str;
 
    }
 
@@ -81,19 +44,6 @@ namespace fc { namespace crypto { namespace blslib {
       return p1._sig == p2._sig;
    }
 
-/*
-   bool operator != ( const bls_signature& p1, const bls_signature& p2) {
-      return !eq_comparator<bls_signature::storage_type>::apply(p1._storage, p2._storage);
-   }
-
-   bool operator < ( const bls_signature& p1, const bls_signature& p2)
-   {
-      return less_comparator<bls_signature::storage_type>::apply(p1._storage, p2._storage);
-   }
-*/
-   size_t hash_value(const bls_signature& b) {
-     //  return std::visit(hash_visitor(), b._storage);
-   }
 } } }  // fc::crypto::blslib
 
 namespace fc

libraries/libfc/test/test_bls.cpp

@@ -114,40 +114,6 @@ BOOST_AUTO_TEST_CASE(bls_sig_verif_hotstuff_types) try {
 
 } FC_LOG_AND_RETHROW();
 
-#warning test being worked under https://github.com/AntelopeIO/leap/issues/1531
-/*
-//test a aggregate signature from string
-BOOST_AUTO_TEST_CASE(bls_sig_verif_string_multi) try {
-
-  bls_signature test_sig_single = bls_signature("SIG_BLS_23PuSu1B72cPe6wxGkKjAaaZqA1Ph79zSoW7omsKKUrnprbA3cJCJVhT48QKUG6ofjYTTg4BA4TrVENWyrxjTomwLX6TGdVg2RYhKH7Kk9X23K5ohuhKQcWQ6AwJJGVSbSp4");
-  std::vector<uint8_t> message_4 = {143,10,193,195,104,126,124,222,124,64,177,164,240,234,110,18,142,236,191,66,223,47,235,248,75,9,172,99,178,26,239,78};
-  bls_private_key sk = bls_private_key(seed_1);
-
-  bls_public_key agg_key = sk.get_public_key();
-  bls_signature agg_sig = test_sig_single;
-
-  cout << 0 << "\n";
-  cout << agg_key.to_string() << "\n";
-  cout << agg_sig.to_string() << "\n";
-
-  for (int i = 1 ;i<14;i++){
-
-    agg_key = aggregate({agg_key, sk.get_public_key() });
-    agg_sig = aggregate({agg_sig, test_sig_single});
-
-    cout << i << "\n";
-    cout << agg_key.to_string() << "\n";
-    cout << agg_sig.to_string() << "\n";
-
-  }
-
-  bool ok = verify(agg_key, message_4, agg_sig);
-
-  BOOST_CHECK_EQUAL(ok, true);
-
-} FC_LOG_AND_RETHROW();
-*/
-
 //test serialization / deserialization of private key, public key and signature
 BOOST_AUTO_TEST_CASE(bls_serialization_test) try {
 
@@ -280,5 +246,33 @@ BOOST_AUTO_TEST_CASE(bls_bad_sig_verif) try {
 
 } FC_LOG_AND_RETHROW();
 
+//test private key base58 encoding
+BOOST_AUTO_TEST_CASE(bls_private_key_string_encoding) try {
+
+  bls_private_key sk = bls_private_key(seed_1);
+
+  bls_public_key pk = sk.get_public_key();
+
+  std::string priv_base58_str = sk.to_string();
+
+  //cout << "priv_base58_str : " << priv_base58_str << "\n";
+
+  bls_private_key sk2 = bls_private_key(priv_base58_str);
+
+  //cout << "sk2 : " << sk2.to_string() << "\n";
+
+  bls_signature signature = sk2.sign(message_1);
+
+  //cout << "pk : " << pk.to_string() << "\n";
+  //cout << "signature : " << signature.to_string() << "\n";
+
+  // Verify the signature
+  bool ok = verify(pk, message_1, signature);
+
+  BOOST_CHECK_EQUAL(ok, true);
+
+} FC_LOG_AND_RETHROW();
+
+
 
 BOOST_AUTO_TEST_SUITE_END()