Feature/vrf (#56)

Yura Zarudniy · web-flow · commit e275235547ab · 2020-01-06T23:04:50.000+03:00
* start impl

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* continue

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* correct interface

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* fix

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* refactor

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* add vrfhash tests

* add sketch for vrf provider test

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* fix sketch

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* remove debug output

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* implement vrf provider tests

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* fix review issues, refactore

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* remove structures already implemented in other PR

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* fix review issues, refactore

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;

* fix review issues

Signed-off-by: Yura Zarudniy &lt;zarudniy@soramitsu.co.jp&gt;
diff --git a/core/common/blob.hpp b/core/common/blob.hpp
@@ -101,7 +101,7 @@ namespace fc::common {
      * @return
      */
     static outcome::result<Blob<size_>> fromSpan(
-        const gsl::span<uint8_t> &span) {
+        const gsl::span<const uint8_t> &span) {
       if (span.size() != size_) {
         return BlobError::INCORRECT_LENGTH;
       }
diff --git a/core/crypto/CMakeLists.txt b/core/crypto/CMakeLists.txt
@@ -7,3 +7,4 @@ add_subdirectory(blake2)
 add_subdirectory(bls)
 add_subdirectory(murmur)
 add_subdirectory(randomness)
+add_subdirectory(vrf)
diff --git a/core/crypto/vrf/CMakeLists.txt b/core/crypto/vrf/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(vrf_provider
+    impl/vrf_provider_impl.cpp
+    vrf_hash_encoder.cpp
+    vrf_types.cpp
+    )
+target_link_libraries(vrf_provider
+    address
+    blob
+    buffer
+    p2p::p2p_sha
+    )
diff --git a/core/crypto/vrf/impl/vrf_provider_impl.cpp b/core/crypto/vrf/impl/vrf_provider_impl.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/vrf/impl/vrf_provider_impl.hpp"
+#include "crypto/vrf/vrf_hash_encoder.hpp"
+
+#include "common/outcome.hpp"
+
+namespace fc::crypto::vrf {
+
+  VRFProviderImpl::VRFProviderImpl(
+      std::shared_ptr<bls::BlsProvider> bls_provider)
+      : bls_provider_(std::move(bls_provider)) {
+    BOOST_ASSERT_MSG(bls_provider_ != nullptr, "bls provider is nullptr");
+  }
+
+  outcome::result<VRFResult> VRFProviderImpl::computeVRF(
+      const VRFSecretKey &secret_key, const VRFParams &params) const {
+    OUTCOME_TRY(hash, encodeVrfParams(params));
+
+    auto &&result = bls_provider_->sign(hash, secret_key);
+    if (!result) {
+      return VRFError::SIGN_FAILED;
+    }
+    return result.value();
+  }
+
+  outcome::result<bool> VRFProviderImpl::verifyVRF(
+      const VRFPublicKey &public_key,
+      const VRFParams &params,
+      const VRFProof &proof) const {
+    OUTCOME_TRY(hash, encodeVrfParams(params));
+    auto &&res = bls_provider_->verifySignature(hash, proof, public_key);
+    if (res.has_failure()) {
+      return VRFError::VERIFICATION_FAILED;
+    }
+    return res.value();
+  }
+}  // namespace fc::crypto::vrf
diff --git a/core/crypto/vrf/impl/vrf_provider_impl.hpp b/core/crypto/vrf/impl/vrf_provider_impl.hpp
@@ -0,0 +1,33 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_VRF_IMPL_VRF_PROVIDER_IMPL_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_VRF_IMPL_VRF_PROVIDER_IMPL_HPP
+
+#include "crypto/bls/bls_provider.hpp"
+#include "crypto/vrf/vrf_provider.hpp"
+
+namespace fc::crypto::vrf {
+
+  class VRFProviderImpl : public VRFProvider {
+   public:
+    ~VRFProviderImpl() override = default;
+
+    explicit VRFProviderImpl(std::shared_ptr<bls::BlsProvider> bls_provider);
+
+    outcome::result<VRFResult> computeVRF(
+        const VRFSecretKey &secret_key, const VRFParams &params) const override;
+
+    outcome::result<bool> verifyVRF(const VRFPublicKey &public_key,
+                                    const VRFParams &message,
+                                    const VRFProof &vrf_proof) const override;
+
+   private:
+    std::shared_ptr<bls::BlsProvider> bls_provider_;
+  };
+
+}  // namespace fc::crypto::vrf
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_VRF_IMPL_VRF_PROVIDER_IMPL_HPP
diff --git a/core/crypto/vrf/vrf_hash_encoder.cpp b/core/crypto/vrf/vrf_hash_encoder.cpp
@@ -0,0 +1,37 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/vrf/vrf_hash_encoder.hpp"
+
+#include <libp2p/crypto/sha/sha256.hpp>
+#include "common/le_encoder.hpp"
+#include "primitives/address/address_codec.hpp"
+
+namespace fc::crypto::vrf {
+  using primitives::address::Protocol;
+
+  outcome::result<VRFHash> encodeVrfParams(const VRFParams &params) {
+    if (params.miner_address.getProtocol() != Protocol::BLS) {
+      return VRFError::ADDRESS_IS_NOT_BLS;
+    }
+    auto &&miner_bytes = primitives::address::encode(params.miner_address);
+
+    common::Buffer out{};
+    auto required_bytes = sizeof(uint64_t) + 2 * sizeof(uint8_t)
+                          + params.message.size() + miner_bytes.size();
+    out.reserve(required_bytes);
+    common::encodeInteger(static_cast<uint64_t>(params.personalization_tag),
+                          out);
+    out.putUint8(0u);
+    out.putBuffer(params.message);
+    out.putUint8(0u);
+    out.put(miner_bytes);
+
+    auto hash = libp2p::crypto::sha256(out);
+
+    return VRFHash::fromSpan(hash);
+  }
+
+}  // namespace fc::crypto::vrf
diff --git a/core/crypto/vrf/vrf_hash_encoder.hpp b/core/crypto/vrf/vrf_hash_encoder.hpp
@@ -0,0 +1,23 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_HASH_ENCODER_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_HASH_ENCODER_HPP
+
+#include "crypto/vrf/vrf_types.hpp"
+
+namespace fc::crypto::vrf {
+
+  /**
+   * @brief encodeVrfParams function used to create VRFHash according to lotus
+   * hash implementation:
+   * https://github.com/filecoin-project/lotus/blob/1914412adf3c81028fcc305b887ca8ad189bc2dc/chain/gen/gen.go#L579
+   * @param params vrf parameters
+   * @return hash value or error
+   */
+  outcome::result<VRFHash> encodeVrfParams(const VRFParams &params);
+}  // namespace fc::crypto::vrf
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_HASH_ENCODER_HPP
diff --git a/core/crypto/vrf/vrf_provider.hpp b/core/crypto/vrf/vrf_provider.hpp
@@ -0,0 +1,47 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_PROVIDER_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_PROVIDER_HPP
+
+#include "crypto/vrf/vrf_types.hpp"
+
+namespace fc::crypto::vrf {
+
+  /**
+   * @class VRFProvider provides VRF functionality according to
+   * https://github.com/filecoin-project/lotus/blob/1914412adf3c81028fcc305b887ca8ad189bc2dc/chain/gen/gen.go#L597
+   */
+  class VRFProvider {
+   public:
+    using Address = primitives::address::Address;
+    using Buffer = common::Buffer;
+
+    virtual ~VRFProvider() = default;
+
+    /**
+     * @brief calculates vrf signature
+     * @param secret_key worker's secret key
+     * @param params vrf parameters
+     * @return generated signature or error
+     */
+    virtual outcome::result<VRFResult> computeVRF(
+        const VRFSecretKey &secret_key, const VRFParams &params) const = 0;
+
+    /**
+     * @brief verifies message against signature and public key
+     * @param public_key worker's public key
+     * @param params vrf parameters
+     * @param proof vrf proof
+     * @return result of verification or error
+     */
+    virtual outcome::result<bool> verifyVRF(const VRFPublicKey &public_key,
+                                            const VRFParams &params,
+                                            const VRFProof &proof) const = 0;
+  };
+
+}  // namespace fc::crypto::vrf
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_PROVIDER_HPP
diff --git a/core/crypto/vrf/vrf_types.cpp b/core/crypto/vrf/vrf_types.cpp
@@ -0,0 +1,22 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/vrf/vrf_types.hpp"
+
+OUTCOME_CPP_DEFINE_CATEGORY(fc::crypto::vrf, VRFError, e) {
+  using fc::crypto::vrf::VRFError;
+  switch (e) {
+    case (VRFError::MINER_ADDRESS_NOT_ID):
+      return "miner address has to be of ID type to calculate hash";
+    case VRFError::VERIFICATION_FAILED:
+      return "VRF verification failed";
+    case VRFError::SIGN_FAILED:
+      return "VRF message sign failed";
+    case VRFError::ADDRESS_IS_NOT_BLS:
+      return "cannot make VRF hash on address, which is not BLS";
+  }
+
+  return "unknown error";
+}
diff --git a/core/crypto/vrf/vrf_types.hpp b/core/crypto/vrf/vrf_types.hpp
@@ -0,0 +1,71 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_TYPES_HPP
+#define CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_TYPES_HPP
+
+#include "common/blob.hpp"
+#include "common/buffer.hpp"
+#include "crypto/bls/bls_types.hpp"
+#include "crypto/randomness/randomness_types.hpp"
+#include "primitives/address/address.hpp"
+
+namespace fc::crypto::vrf {
+
+  /**
+   * @brief vrf public key type
+   */
+  using VRFPublicKey = bls::PublicKey;
+  /**
+   * @brief vrf secret key type
+   */
+  using VRFSecretKey = bls::PrivateKey;
+  /**
+   * @brief vrf proof value
+   */
+  using VRFProof = bls::Signature;
+
+  /**
+   * @brief result of computing vrf
+   */
+  using VRFResult = bls::Signature;
+
+  /**
+   * @brief return value of vrf hash encode
+   */
+  using VRFHash = common::Hash256;
+
+  /**
+   * @brief vrf parameters structure
+   */
+  struct VRFParams {
+    randomness::DomainSeparationTag personalization_tag;
+    primitives::address::Address miner_address;
+    common::Buffer message;
+  };
+
+  /**
+   * @brief VRF key pair definition
+   */
+  struct VRFKeyPair {
+    VRFPublicKey public_key;
+    VRFSecretKey secret_key;
+  };
+
+  /**
+   * @brief vrf errors enumeration
+   */
+  enum class VRFError {
+    MINER_ADDRESS_NOT_ID =
+        1,                // miner address need to be id type to calculate hash
+    VERIFICATION_FAILED,  // vrf verification failed
+    SIGN_FAILED,          // vrf sing message failed
+    ADDRESS_IS_NOT_BLS,   // vrf hash can be based only on bls
+  };
+}  // namespace fc::crypto::vrf
+
+OUTCOME_HPP_DECLARE_ERROR(fc::crypto::vrf, VRFError)
+
+#endif  // CPP_FILECOIN_CORE_CRYPTO_VRF_VRF_TYPES_HPP
diff --git a/test/core/crypto/CMakeLists.txt b/test/core/crypto/CMakeLists.txt
@@ -26,3 +26,5 @@ target_link_libraries(murmur_test
     )
 
 add_subdirectory(randomness)
+add_subdirectory(vrf)
+
diff --git a/test/core/crypto/vrf/CMakeLists.txt b/test/core/crypto/vrf/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+addtest(vrf_encoder_test
+    vrf_encoder_test.cpp
+    )
+target_link_libraries(vrf_encoder_test
+    vrf_provider
+    )
+
+addtest(vrf_provider_test
+    vrf_provider_test.cpp
+    )
+target_link_libraries(vrf_provider_test
+    vrf_provider
+    )
diff --git a/test/core/crypto/vrf/vrf_encoder_test.cpp b/test/core/crypto/vrf/vrf_encoder_test.cpp
@@ -0,0 +1,59 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "crypto/vrf/vrf_hash_encoder.hpp"
+
+#include <gtest/gtest.h>
+#include "testutil/literals.hpp"
+#include "testutil/outcome.hpp"
+#include "testutil/primitives/address_utils.hpp"
+
+using fc::common::Blob;
+using fc::common::Buffer;
+using fc::crypto::randomness::DomainSeparationTag;
+using fc::crypto::vrf::encodeVrfParams;
+using fc::crypto::vrf::VRFHash;
+using fc::crypto::vrf::VRFParams;
+using fc::primitives::address::Address;
+
+struct VRFHashEncoderTest : public ::testing::Test {
+  Buffer message{"a1b2c3"_unhex};
+  Blob<48> bls_blob =
+      "1234567890123456789012345678901234567890"
+      "1234567890123456789012345678901234567890"
+      "1122334455667788"_blob48;
+  Address id_address;
+  Address bls_address;
+  VRFHash vrf_hash;
+
+  void SetUp() override {
+    id_address = makeIdAddress(123u);
+    bls_address = makeBlsAddress(bls_blob);
+    vrf_hash = VRFHash{
+        "661E466606D72B22721484220DCF3FFB44A3ACA3A5D2CC883C9B26281C8E8B27"_blob32};
+  }
+};
+
+/**
+ * @given id-based address, DST-tag value and some message
+ * @when hash provider method `create` is called
+ * @then error is returned
+ */
+TEST_F(VRFHashEncoderTest,
+       HashIdAddressFail){EXPECT_OUTCOME_FALSE_1(encodeVrfParams(VRFParams{
+    DomainSeparationTag::TicketProductionDST, id_address, message}))}
+
+/**
+ * @given bls-based address, DST-tag value and some message
+ * @when encode vrf parameters
+ * @then valid hash is returned and its value is correct
+ */
+TEST_F(VRFHashEncoderTest, HashBlsAddressSuccess) {
+  EXPECT_OUTCOME_TRUE(
+      result,
+      encodeVrfParams(VRFParams{
+          DomainSeparationTag::TicketProductionDST, bls_address, message}))
+  ASSERT_EQ(result, vrf_hash);
+}
diff --git a/test/core/crypto/vrf/vrf_provider_test.cpp b/test/core/crypto/vrf/vrf_provider_test.cpp
diff --git a/test/testutil/literals.hpp b/test/testutil/literals.hpp
diff --git a/test/testutil/primitives/address_utils.hpp b/test/testutil/primitives/address_utils.hpp

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ namespace fc::common {`
`101`	`101`	`* @return`
`102`	`102`	`*/`
`103`	`103`	`static outcome::result<Blob<size_>> fromSpan(`
`104`		`- const gsl::span<uint8_t> &span) {`
	`104`	`+ const gsl::span<const uint8_t> &span) {`
`105`	`105`	`if (span.size() != size_) {`
`106`	`106`	`return BlobError::INCORRECT_LENGTH;`
`107`	`107`	`}`