Add Noise Protocol Support (#90)

Signed-off-by: Igor Egorov <[email protected]>

Co-authored-by: artyom-yurin <[email protected]>
Co-authored-by: turuslan <[email protected]>

Author: 3 people

example/01-echo/README.md

@@ -9,8 +9,8 @@ The last two examples can be used to test a compatibility between the implementa
 
 ## C++ Server and Client
 
-Currently, `libp2p_echo_server` can operate in two modes - via Plaintext or SECIO security protocols.
-By default, it is launched in SECIO secured mode.
+Currently, `libp2p_echo_server` can operate in two modes - via Plaintext or Noise security protocols.
+By default, it is launched in Noise secured mode.
 To run it with Plaintext exclusive mode just add `-insecure` command-line argument.
 
 ```bash

example/01-echo/go.mod

@@ -3,22 +3,24 @@ module github.com/libp2p/go-libp2p-examples
 require (
 	github.com/gogo/protobuf v1.3.1
 	github.com/google/uuid v1.1.1
-	github.com/ipfs/go-datastore v0.3.1
-	github.com/ipfs/go-log v0.0.1
-	github.com/libp2p/go-libp2p v0.5.0
+	github.com/ipfs/go-datastore v0.4.4
+	github.com/ipfs/go-log v1.0.3
+	github.com/libp2p/go-libp2p v0.8.1
 	github.com/libp2p/go-libp2p-autonat-svc v0.1.0
-	github.com/libp2p/go-libp2p-circuit v0.1.4
+	github.com/libp2p/go-libp2p-circuit v0.2.1
 	github.com/libp2p/go-libp2p-connmgr v0.2.1
-	github.com/libp2p/go-libp2p-core v0.3.0
-	github.com/libp2p/go-libp2p-discovery v0.2.0
+	github.com/libp2p/go-libp2p-core v0.5.1
+	github.com/libp2p/go-libp2p-discovery v0.3.0
 	github.com/libp2p/go-libp2p-kad-dht v0.4.1
+	github.com/libp2p/go-libp2p-noise v0.1.2
 	github.com/libp2p/go-libp2p-quic-transport v0.2.2
 	github.com/libp2p/go-libp2p-routing v0.1.0
-	github.com/libp2p/go-libp2p-secio v0.2.1
-	github.com/libp2p/go-libp2p-swarm v0.2.2
-	github.com/libp2p/go-libp2p-tls v0.1.2
-	github.com/multiformats/go-multiaddr v0.2.0
-	github.com/multiformats/go-multiaddr-net v0.1.1
+	github.com/libp2p/go-libp2p-secio v0.2.2
+	github.com/libp2p/go-libp2p-swarm v0.2.3
+	github.com/libp2p/go-libp2p-tls v0.1.3
+	github.com/multiformats/go-multiaddr v0.2.1
+	github.com/multiformats/go-multiaddr-net v0.1.4
+	github.com/sabhiram/go-tracey v0.0.0-20180906172802-620b5b676e3c // indirect
 	github.com/whyrusleeping/go-logging v0.0.1
 )
 

example/01-echo/libp2p_client.go

@@ -17,9 +17,12 @@ import (
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/peerstore"
+	noise "github.com/libp2p/go-libp2p-noise"
+
 
 	golog "github.com/ipfs/go-log"
 	ma "github.com/multiformats/go-multiaddr"
+	gologging "github.com/whyrusleeping/go-logging"
 )
 
 // makeBasicHost creates a LibP2P host with a random peer ID listening on the
@@ -52,6 +55,8 @@ func makeBasicHost(listenPort int, insecure bool, randseed int64) (host.Host, er
 
 	if insecure {
 		opts = append(opts, libp2p.NoSecurity)
+	} else {
+	    opts = append(opts, libp2p.Security(noise.ID, noise.New))
 	}
 
 	basicHost, err := libp2p.New(context.Background(), opts...)
@@ -81,7 +86,7 @@ func main() {
 	// string IDs (i.e. "swarm"). We can control the verbosity level for
 	// all loggers with:
 	// golog.SetAllLoggers(golog.LevelInfo) // Change to DEBUG for extra info
-	golog.SetDebugLogging()
+	golog.SetAllLoggers(golog.LogLevel(gologging.INFO)) // Change to DEBUG for extra info
 
 	// Parse options from the command line
 	listenF := flag.Int("l", 0, "wait for incoming connections")

example/01-echo/libp2p_echo_server.cpp

@@ -12,8 +12,8 @@
 #include <libp2p/host/basic_host.hpp>
 #include <libp2p/injector/host_injector.hpp>
 #include <libp2p/protocol/echo.hpp>
+#include <libp2p/security/noise.hpp>
 #include <libp2p/security/plaintext.hpp>
-#include <libp2p/security/secio.hpp>
 
 bool isInsecure(int argc, char **argv) {
   if (2 == argc) {
@@ -34,7 +34,7 @@ struct ServerContext {
 ServerContext initSecureServer(const libp2p::crypto::KeyPair &keypair) {
   auto injector = libp2p::injector::makeHostInjector(
       libp2p::injector::useKeyPair(keypair),
-      libp2p::injector::useSecurityAdaptors<libp2p::security::Secio>());
+      libp2p::injector::useSecurityAdaptors<libp2p::security::Noise>());
   auto host = injector.create<std::shared_ptr<libp2p::Host>>();
   auto context = injector.create<std::shared_ptr<boost::asio::io_context>>();
   return {.host = host, .io_context = context};

include/libp2p/common/byteutil.hpp

@@ -22,16 +22,31 @@ namespace libp2p::common {
    */
   ByteArray &putUint16BE(ByteArray &bytes, uint16_t n);
 
+  /**
+   * Put a 16-bit number into the byte array in Little Endian encoding
+   */
+  ByteArray &putUint16LE(ByteArray &bytes, uint16_t n);
+
   /**
    * Put an 32-bit number into the byte array in Big Endian encoding
    */
   ByteArray &putUint32BE(ByteArray &bytes, uint32_t n);
 
+  /**
+   * Put a 32-bit number into the byte array in Little Endian encoding
+   */
+  ByteArray &putUint32LE(ByteArray &bytes, uint32_t n);
+
   /**
    * Put an 64-bit number into the byte array in Big Endian encoding
    */
   ByteArray &putUint64BE(ByteArray &bytes, uint64_t n);
 
+  /**
+   * Put a 64-bit number into the byte array in Little Endian encoding
+   */
+  ByteArray &putUint64LE(ByteArray &bytes, uint64_t n);
+
   /**
    * Convert value, to which the pointer (\param v) references, to the value of
    * (\tparam T)

include/libp2p/crypto/chachapoly.hpp

@@ -0,0 +1,66 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_HPP
+#define LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_HPP
+
+#include <array>
+
+#include <gsl/span>
+#include <libp2p/common/byteutil.hpp>
+#include <libp2p/common/types.hpp>
+#include <libp2p/crypto/common.hpp>
+#include <libp2p/outcome/outcome.hpp>
+
+namespace libp2p::crypto::chachapoly {
+  using libp2p::common::ByteArray;
+  using Key = std::array<uint8_t, 32>;
+  using Nonce = std::array<uint8_t, 12>;
+
+  class ChaCha20Poly1305 {
+   public:
+    virtual ~ChaCha20Poly1305() = default;
+
+    /**
+     * Does authenticated encryption with associated data (AEAD)
+     * @param plaintext to cipher
+     * @param nonce - custom specified nonce bytes
+     * @param associated_data - data for message authentication
+     * @return ciphertext bytes
+     */
+    virtual outcome::result<ByteArray> encrypt(
+        const Nonce &nonce, gsl::span<const uint8_t> plaintext,
+        gsl::span<const uint8_t> aad) = 0;
+
+    /**
+     * Does authenticated decryption with associated data (AEAD)
+     * @param ciphertext bytes to decrypt
+     * @param nonce - custom specified nonce bytes
+     * @param associated_data - data for message authentication
+     * @return plaintext bytes
+     */
+    virtual outcome::result<ByteArray> decrypt(
+        const Nonce &nonce, gsl::span<const uint8_t> ciphertext,
+        gsl::span<const uint8_t> aad) = 0;
+
+    /**
+     * Convert 64-bit integer to 12-bit long byte sequence with four zero bytes
+     * at the beginning
+     * @param n - an integer to convert
+     * @return - bytes vector
+     */
+    inline Nonce uint64toNonce(uint64_t n) const {
+      ByteArray result(4, 0);
+      result.reserve(12);
+      libp2p::common::putUint64LE(result, n);
+      Nonce nonce;
+      std::copy_n(result.begin(), nonce.size(), nonce.begin());
+      return nonce;
+    }
+  };
+
+}  // namespace libp2p::crypto::chachapoly
+
+#endif  // LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_HPP

include/libp2p/crypto/chachapoly/chachapoly_impl.hpp

@@ -0,0 +1,37 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_CHACHAPOLY_IMPL_HPP
+#define LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_CHACHAPOLY_IMPL_HPP
+
+#include <openssl/evp.h>
+#include <libp2p/common/logger.hpp>
+#include <libp2p/crypto/chachapoly.hpp>
+
+namespace libp2p::crypto::chachapoly {
+
+  class ChaCha20Poly1305Impl : public ChaCha20Poly1305 {
+   public:
+    explicit ChaCha20Poly1305Impl(Key key);
+
+    outcome::result<ByteArray> encrypt(const Nonce &nonce,
+                                       gsl::span<const uint8_t> plaintext,
+                                       gsl::span<const uint8_t> aad) override;
+
+    outcome::result<ByteArray> decrypt(const Nonce &nonce,
+                                       gsl::span<const uint8_t> ciphertext,
+                                       gsl::span<const uint8_t> aad) override;
+
+   private:
+    const Key key_;
+    const EVP_CIPHER *cipher_;
+    const int block_size_;
+    libp2p::common::Logger log_ =
+        libp2p::common::createLogger("ChaChaPolyImpl");
+  };
+
+}  // namespace libp2p::crypto::chachapoly
+
+#endif  // LIBP2P_INCLUDE_LIBP2P_CRYPTO_CHACHAPOLY_CHACHAPOLY_IMPL_HPP

include/libp2p/crypto/common_functions.hpp

@@ -6,16 +6,33 @@
 #ifndef LIBP2P_COMMON_FUNCTIONS_HPP
 #define LIBP2P_COMMON_FUNCTIONS_HPP
 
+#include <algorithm>
+#include <array>
 #include <memory>
 #include <vector>
-#include <array>
 
 #include <openssl/ec.h>
 #include <openssl/evp.h>
 #include <gsl/span>
 #include <libp2p/outcome/outcome.hpp>
 
 namespace libp2p::crypto {
+
+  template <typename Array>
+  std::vector<uint8_t> asVector(const Array &key) {
+    std::vector<uint8_t> result;
+    result.resize(key.size(), 0);
+    std::copy_n(key.begin(), key.size(), result.begin());
+    return result;
+  }
+
+  template <typename Array>
+  Array asArray(const std::vector<uint8_t> &bytes) {
+    Array key;
+    std::copy_n(bytes.begin(), key.size(), key.begin());
+    return key;
+  }
+
   /**
    * Initializes EC_KEY structure with private and public key from private key
    * bytes
@@ -66,10 +83,9 @@ namespace libp2p::crypto {
    * @param key - EC public key
    * @return signature status or error code
    */
-  outcome::result<bool> VerifyEcSignature(
-      gsl::span<const uint8_t> digest,
-      gsl::span<const uint8_t> signature,
-      const std::shared_ptr<EC_KEY> &key);
+  outcome::result<bool> VerifyEcSignature(gsl::span<const uint8_t> digest,
+                                          gsl::span<const uint8_t> signature,
+                                          const std::shared_ptr<EC_KEY> &key);
 
 }  // namespace libp2p::crypto
 

include/libp2p/crypto/hasher.hpp

@@ -0,0 +1,45 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef LIBP2P_SRC_CRYPTO_HASHER_HPP
+#define LIBP2P_SRC_CRYPTO_HASHER_HPP
+
+#include <gsl/span>
+#include <libp2p/crypto/common.hpp>
+#include <libp2p/outcome/outcome.hpp>
+
+namespace libp2p::crypto {
+
+  using libp2p::crypto::common::HashType;
+
+  class Hasher {
+   public:
+    virtual ~Hasher() = default;
+
+    /// appends a new chunk of data
+    virtual outcome::result<void> write(gsl::span<const uint8_t> data) = 0;
+
+    /**
+     * Calculates the current digest.
+     * Does not affect the internal state.
+     * New data still could be fed via write method.
+     */
+    virtual outcome::result<std::vector<uint8_t>> digest() = 0;
+
+    /// resets the internal state
+    virtual outcome::result<void> reset() = 0;
+
+    /// hash size in bytes
+    virtual size_t digestSize() const = 0;
+
+    /// block size in bytes for the most optimal hash update via write method
+    virtual size_t blockSize() const = 0;
+
+    /// runtime identifiable hasher type
+    virtual HashType hashType() const = 0;
+  };
+}  // namespace libp2p::crypto
+
+#endif  // LIBP2P_SRC_CRYPTO_HASHER_HPP

include/libp2p/crypto/hmac_provider.hpp

@@ -9,22 +9,27 @@
 #include <gsl/span>
 #include <libp2p/common/types.hpp>
 #include <libp2p/crypto/common.hpp>
+#include <libp2p/crypto/hasher.hpp>
 #include <libp2p/outcome/outcome.hpp>
 
 namespace libp2p::crypto::hmac {
+
+  using ByteArray = libp2p::common::ByteArray;
+  using HashType = common::HashType;
+
+  /// HMAC that supports stream data feeding interface
+  class HmacProviderCtr : public Hasher {};
+
   /**
    * @class HmacProvider provides HMAC functionality
    * allows calculating message authentication code
    * involving a cryptographic hash function
    * and a secret cryptographic key
    */
   class HmacProvider {
-    using HashType = common::HashType;
-
    public:
-    using ByteArray = libp2p::common::ByteArray;
-
     virtual ~HmacProvider() = default;
+
     /**
      * @brief calculates digests
      * @param hash_type hash type