FIL-72 Message component (#58)

Signed-off-by: Eugene Kovalev <[email protected]>

Author: ekovalev

core/crypto/CMakeLists.txt

@@ -8,3 +8,4 @@ add_subdirectory(bls)
 add_subdirectory(murmur)
 add_subdirectory(randomness)
 add_subdirectory(vrf)
+add_subdirectory(signature)

core/crypto/signature/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+add_library(signature
+    signature.cpp
+    )
+target_link_libraries(signature
+    outcome
+    )

core/crypto/signature/signature.cpp

@@ -0,0 +1,31 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/signature/signature.hpp"
+
+OUTCOME_CPP_DEFINE_CATEGORY(fc::crypto::signature, SignatureError, e) {
+  using fc::crypto::signature::SignatureError;
+  switch (e) {
+    case (SignatureError::INVALID_SIGNATURE_LENGTH):
+      return "SignatureError: invalid signature length";
+    case (SignatureError::WRONG_SIGNATURE_TYPE):
+      return "SignatureError: wrong signature type";
+    case (SignatureError::INVALID_KEY_LENGTH):
+      return "SignatureError: invalid key length";
+    default:
+      return "SignatureError: unknown error";
+  };
+}
+
+namespace fc::crypto::signature {
+
+  Type typeCode(const Signature &s) {
+    return visit_in_place(
+        s,
+        [](const BlsSignature &v) { return Type::BLS; },
+        [](const Secp256k1Signature &v) { return Type::SECP256K1; });
+  }
+
+}  // namespace fc::crypto::signature

core/crypto/signature/signature.hpp

@@ -0,0 +1,99 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CRYPTO_SIGNATURE_HPP
+#define CPP_FILECOIN_CRYPTO_SIGNATURE_HPP
+
+#include <boost/variant.hpp>
+
+#include "codec/cbor/cbor.hpp"
+#include "common/outcome_throw.hpp"
+#include "common/visitor.hpp"
+#include "crypto/bls/bls_types.hpp"
+#include "crypto/secp256k1/secp256k1_provider.hpp"
+
+namespace fc::crypto::signature {
+  using BlsSignature = bls::Signature;
+  using Secp256k1Signature = secp256k1::Signature;
+
+  enum Type : uint8_t { SECP256K1 = 0x1, BLS = 0x2 };
+
+  constexpr uint64_t kSignatureMaxLength = 200;
+
+  /**
+   * @brief Signature error codes
+   */
+  enum class SignatureError {
+    INVALID_SIGNATURE_LENGTH = 1,
+    WRONG_SIGNATURE_TYPE,
+    INVALID_KEY_LENGTH
+  };
+
+  struct Signature : public boost::variant<BlsSignature, Secp256k1Signature> {
+    using variant::variant;
+    using base_type = boost::variant<BlsSignature, Secp256k1Signature>;
+
+    inline bool operator==(const Signature &other) const {
+      return base_type::operator==(static_cast<const base_type &>(other));
+    }
+  };
+
+  Type typeCode(const Signature &s);
+
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference<Stream>::type::is_cbor_encoder_stream>>
+  Stream &operator<<(Stream &&s, const Signature &signature) noexcept {
+    std::vector<uint8_t> bytes{};
+    visit_in_place(signature,
+                   [&bytes](const BlsSignature &v) {
+                     bytes.push_back(BLS);
+                     return bytes.insert(bytes.end(), v.begin(), v.end());
+                   },
+                   [&bytes](const Secp256k1Signature &v) {
+                     bytes.push_back(SECP256K1);
+                     return bytes.insert(bytes.end(), v.begin(), v.end());
+                   });
+    return s << bytes;
+  }
+
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference<Stream>::type::is_cbor_decoder_stream>>
+  Stream &operator>>(Stream &&s, Signature &signature) {
+    std::vector<uint8_t> data{};
+    s >> data;
+    if (data.empty() || data.size() > kSignatureMaxLength) {
+      outcome::raise(SignatureError::INVALID_SIGNATURE_LENGTH);
+    }
+    switch (data[0]) {
+      case (SECP256K1):
+        signature = Secp256k1Signature(std::next(data.begin()), data.end());
+        break;
+      case (BLS): {
+        BlsSignature blsSig{};
+        if (data.size() != blsSig.size() + 1) {
+          outcome::raise(SignatureError::INVALID_SIGNATURE_LENGTH);
+        }
+        std::copy_n(std::make_move_iterator(std::next(data.begin())),
+                    blsSig.size(),
+                    blsSig.begin());
+        signature = blsSig;
+        break;
+      }
+      default:
+        outcome::raise(SignatureError::WRONG_SIGNATURE_TYPE);
+    };
+    return s;
+  }
+
+}  // namespace fc::crypto::signature
+
+/**
+ * @brief Outcome errors declaration
+ */
+OUTCOME_HPP_DECLARE_ERROR(fc::crypto::signature, SignatureError);
+
+#endif  // CPP_FILECOIN_CRYPTO_SIGNATURE_HPP

core/storage/keystore/CMakeLists.txt

@@ -12,4 +12,5 @@ target_link_libraries(keystore
     bls_provider
     filestore
     outcome
+    signature
     )

core/storage/keystore/keystore.cpp

@@ -9,6 +9,7 @@
 
 #include "common/visitor.hpp"
 
+using fc::crypto::signature::Signature;
 using fc::primitives::address::Protocol;
 using fc::storage::keystore::KeyStore;
 using fc::storage::keystore::KeyStoreError;
@@ -43,8 +44,8 @@ fc::outcome::result<bool> KeyStore::checkAddress(
   return KeyStoreError::WRONG_ADDRESS;
 }
 
-fc::outcome::result<KeyStore::TSignature> KeyStore::sign(
-    const Address &address, gsl::span<uint8_t> data) noexcept {
+fc::outcome::result<Signature> KeyStore::sign(
+    const Address &address, gsl::span<const uint8_t> data) noexcept {
   OUTCOME_TRY(private_key, get(address));
   OUTCOME_TRY(valid, checkAddress(address, private_key));
   if (!valid) return KeyStoreError::WRONG_ADDRESS;
@@ -67,7 +68,7 @@ fc::outcome::result<KeyStore::TSignature> KeyStore::sign(
 
 fc::outcome::result<bool> KeyStore::verify(const Address &address,
                                            gsl::span<const uint8_t> data,
-                                           const TSignature &signature) const
+                                           const Signature &signature) const
     noexcept {
   OUTCOME_TRY(private_key, get(address));
   OUTCOME_TRY(valid, checkAddress(address, private_key));

core/storage/keystore/keystore.hpp

@@ -13,30 +13,31 @@
 #include "crypto/bls/bls_provider.hpp"
 #include "crypto/bls/bls_types.hpp"
 #include "crypto/secp256k1/secp256k1_provider.hpp"
+#include "crypto/signature/signature.hpp"
 #include "primitives/address/address.hpp"
 #include "primitives/address/address_verifier.hpp"
 #include "storage/keystore/keystore_error.hpp"
 
 namespace fc::storage::keystore {
 
   using crypto::bls::BlsProvider;
-  using libp2p::crypto::secp256k1::Secp256k1Provider;
+  using crypto::secp256k1::Secp256k1Provider;
+  using BlsKeyPair = crypto::bls::KeyPair;
+  using BlsPrivateKey = crypto::bls::PrivateKey;
+  using BlsSignature = crypto::bls::Signature;
+  using Secp256k1KeyPair = crypto::secp256k1::KeyPair;
+  using Secp256k1PrivateKey = crypto::secp256k1::PrivateKey;
+  using Secp256k1Signature = crypto::secp256k1::Signature;
+  using crypto::signature::Signature;
   using primitives::address::Address;
-  using BlsKeyPair = fc::crypto::bls::KeyPair;
-  using BlsPrivateKey = fc::crypto::bls::PrivateKey;
-  using BlsSignature = fc::crypto::bls::Signature;
-  using Secp256k1KeyPair = libp2p::crypto::secp256k1::KeyPair;
-  using Secp256k1PrivateKey = libp2p::crypto::secp256k1::PrivateKey;
-  using Secp256k1Signature = libp2p::crypto::secp256k1::Signature;
-  using fc::primitives::address::AddressVerifier;
+  using primitives::address::AddressVerifier;
 
   /**
    * An interface to a facility to store and use cryptographic keys
    */
   class KeyStore {
    public:
     using TPrivateKey = boost::variant<BlsPrivateKey, Secp256k1PrivateKey>;
-    using TSignature = boost::variant<BlsSignature, Secp256k1Signature>;
 
     KeyStore(std::shared_ptr<BlsProvider> blsProvider,
              std::shared_ptr<Secp256k1Provider> secp256K1Provider,
@@ -77,8 +78,9 @@ namespace fc::storage::keystore {
      * @param data to sign
      * @return signature
      */
-    virtual outcome::result<TSignature> sign(const Address &address,
-                                             gsl::span<uint8_t> data) noexcept;
+    virtual outcome::result<Signature> sign(
+        const Address &address, gsl::span<const uint8_t> data) noexcept;
+
     /**
      * @brief verify signature
      * @param address of keypair
@@ -87,7 +89,7 @@ namespace fc::storage::keystore {
      */
     virtual outcome::result<bool> verify(const Address &address,
                                          gsl::span<const uint8_t> data,
-                                         const TSignature &signature) const
+                                         const Signature &signature) const
         noexcept;
 
    protected:

core/vm/CMakeLists.txt

@@ -6,3 +6,4 @@
 add_subdirectory(actor)
 add_subdirectory(exit_code)
 add_subdirectory(state)
+add_subdirectory(message)

core/vm/message/CMakeLists.txt

@@ -0,0 +1,19 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+add_library(message
+    message.cpp
+    message_util.cpp
+    impl/message_signer_impl.cpp
+    )
+
+target_link_libraries(message
+    Boost::boost
+    address
+    logger
+    keystore
+    outcome
+    signature
+    )

core/vm/message/impl/message_signer_impl.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "vm/message/impl/message_signer_impl.hpp"
+#include "vm/message/message_util.hpp"
+
+namespace fc::vm::message {
+
+  MessageSignerImpl::MessageSignerImpl(std::shared_ptr<KeyStore> ks)
+      : keystore_(std::move(ks)),
+        logger_(common::createLogger("message_signer")) {}
+
+  outcome::result<SignedMessage> MessageSignerImpl::sign(
+      const Address &address, const UnsignedMessage &msg) noexcept {
+    auto maybe_cid = cid(msg);
+    if (maybe_cid.has_error()) {
+      logger_->error(maybe_cid.error().message());
+      return outcome::failure(MessageError::SERIALIZATION_FAILURE);
+    }
+    auto maybe_cid_bytes =
+        libp2p::multi::ContentIdentifierCodec::encode(maybe_cid.value());
+    if (maybe_cid_bytes.has_error()) {
+      logger_->error(maybe_cid_bytes.error().message());
+      return outcome::failure(MessageError::SERIALIZATION_FAILURE);
+    }
+    OUTCOME_TRY(signature, keystore_->sign(address, maybe_cid_bytes.value()));
+    return SignedMessage{msg, signature};
+  }
+
+  outcome::result<UnsignedMessage> MessageSignerImpl::verify(
+      const Address &address, const SignedMessage &msg) const noexcept {
+    auto maybe_cid = cid(msg.message);
+    if (maybe_cid.has_error()) {
+      logger_->error(maybe_cid.error().message());
+      return outcome::failure(MessageError::SERIALIZATION_FAILURE);
+    }
+    auto maybe_cid_bytes =
+        libp2p::multi::ContentIdentifierCodec::encode(maybe_cid.value());
+    if (maybe_cid_bytes.has_error()) {
+      logger_->error(maybe_cid_bytes.error().message());
+      return outcome::failure(MessageError::SERIALIZATION_FAILURE);
+    }
+    OUTCOME_TRY(
+        res,
+        keystore_->verify(address, maybe_cid_bytes.value(), msg.signature));
+    if (!res) {
+      return outcome::failure(MessageError::VERIFICATION_FAILURE);
+    }
+    return msg.message;
+  }
+
+};  // namespace fc::vm::message