Update libsodium impl and add benchmark test (#303)

.gitignore

@@ -52,5 +52,5 @@ test/fuzz/**/corpus
 test/fuzz/**/crashers
 test/fuzz/**/suppressions
 test/fuzz/**/*.zip
-crypto/vrf/internal/vrf/lib
-crypto/vrf/internal/vrf/include
+node/data
+crypto/vrf/internal/vrf/sodium

Makefile

@@ -3,26 +3,20 @@ SRCPATH=$(shell pwd)
 OUTPUT?=build/ostracon
 
 INCLUDE = -I=${GOPATH}/src/github.com/line/ostracon -I=${GOPATH}/src -I=${GOPATH}/src/github.com/gogo/protobuf/protobuf
-BUILD_TAGS?='ostracon'
+BUILD_TAGS?=ostracon
 VERSION := $(shell git describe --always)
-CGO_OPTPTION=0
 LIBSODIUM_TARGET=
-PREPARE_LIBSODIUM_TARGET=
 ifeq ($(LIBSODIUM), 1)
- BUILD_TAGS='libsodium ostracon'
  LIBSODIUM_TARGET=libsodium
-ifneq ($(OS), Windows_NT)
-ifeq ($(shell uname -s), Linux)
- PREPARE_LIBSODIUM_TARGET=prepare-libsodium-linux
+ BUILD_TAGS += libsodium
 endif
-endif
-endif
-LIBSODIM_BUILD_TAGS='libsodium ostracon'
 LD_FLAGS = -X github.com/line/ostracon/version.Version=$(VERSION)
 BUILD_FLAGS = -mod=readonly -ldflags "$(LD_FLAGS)"
 HTTPS_GIT := https://github.com/line/ostracon.git
 DOCKER_BUF := docker run -v $(shell pwd):/workspace --workdir /workspace bufbuild/buf
 CGO_ENABLED ?= 0
+TARGET_OS ?= $(shell go env GOOS)
+TARGET_ARCH ?= $(shell go env GOARCH)
 
 # handle nostrip
 ifeq (,$(findstring nostrip,$(OSTRACON_BUILD_OPTIONS)))
@@ -72,7 +66,7 @@ build: $(LIBSODIUM_TARGET)
  CGO_ENABLED=1 go build $(BUILD_FLAGS) -tags "$(BUILD_TAGS)" -o $(OUTPUT) ./cmd/ostracon/
 .PHONY: build
 
-install:
+install: $(LIBSODIUM_TARGET)
  CGO_ENABLED=1 go install $(BUILD_FLAGS) -tags "$(BUILD_TAGS)" ./cmd/ostracon
 .PHONY: install
 
@@ -151,15 +145,21 @@ install_abci:
 ########################################
 ### libsodium
 
-prepare-libsodium-linux:
- apt-get update && apt-get -y install libtool libboost-all-dev autoconf build-essential
+VRF_ROOT = $(SRCPATH)/crypto/vrf/internal/vrf
+LIBSODIUM_ROOT = $(VRF_ROOT)/libsodium
+LIBSODIUM_OS = $(VRF_ROOT)/sodium/$(TARGET_OS)_$(TARGET_ARCH)
 
 libsodium:
- cd $(SRCPATH)/crypto/vrf/internal/vrf/libsodium && \
- ./autogen.sh && \
- ./configure --disable-shared --prefix="$(SRCPATH)/crypto/vrf/internal/vrf/" && \
- $(MAKE) && \
- $(MAKE) install
+ rm -rf $(LIBSODIUM_ROOT)
+ mkdir $(LIBSODIUM_ROOT)
+ git submodule update --init --recursive
+ @if [ ! -f $(LIBSODIUM_OS)/lib/libsodium.a ]; then \
+ cd $(LIBSODIUM_ROOT) && \
+ ./autogen.sh && \
+ ./configure --disable-shared --prefix="$(LIBSODIUM_OS)" && \
+ $(MAKE) && \
+ $(MAKE) install; \
+ fi
 
 ########################################
 ### Distribution
@@ -287,9 +287,9 @@ DOCKER_CMD = docker run --rm \
  -v `pwd`:$(DOCKER_HOME) \
  -w $(DOCKER_HOME)
 DOCKER_IMG = golang:1.15-alpine
-BUILD_CMD = apk add --update --no-cache git make gcc libc-dev build-base curl jq file gmp-dev clang \
+BUILD_CMD = apk add --update --no-cache git make gcc libc-dev build-base curl jq bash file gmp-dev clang libtool autoconf automake \
  && cd $(DOCKER_HOME) \
- && make build-linux
+ && LIBSODIUM=$(LIBSODIUM) make build-linux
 
 # Login docker-container for confirmation building linux binary
 build-shell:

README.md

@@ -10,6 +10,25 @@ Ostracon is forked from Tendermint Core at 2021-03-15.
 
 # Quick Start
 
+## git clone
+```shell
+git clone https://github.com/line/ostracon.git
+# or
+git clone git@github.com:line/ostracon.git
+```
+
+### git clone with recursive if you want to use libsodium
+```shell
+git clone --recursive https://github.com/line/ostracon.git
+# or
+git clone --recursive git@github.com:line/ostracon.git
+```
+
+### git submodule if you forget to clone with submodule
+```shell
+git submodule update --init --recursive
+```
+
 ## Local Standalone
 **Build**
  ```sh

crypto/composite/composite.go

@@ -92,9 +92,9 @@ func (sk PrivKey) Sign(msg []byte) ([]byte, error) {
  return sk.SignKey.Sign(msg)
 }
 
-// VRFProve generates a VRF Proof for given seed to generate a verifiable random.
-func (sk PrivKey) VRFProve(seed []byte) (crypto.Proof, error) {
- return sk.VrfKey.VRFProve(seed)
+// VRFProve generates a VRF Proof for given message to generate a verifiable random.
+func (sk PrivKey) VRFProve(message []byte) (crypto.Proof, error) {
+ return sk.VrfKey.VRFProve(message)
 }
 
 func (sk PrivKey) PubKey() crypto.PubKey {

crypto/ed25519/ed25519.go

@@ -3,6 +3,7 @@ package ed25519
 import (
  "bytes"
  "crypto/subtle"
+ "encoding/hex"
  "fmt"
  "io"
 
@@ -60,9 +61,9 @@ func (privKey PrivKey) Sign(msg []byte) ([]byte, error) {
  return signatureBytes, nil
 }
 
-// VRFProve generates a VRF Proof for given seed to generate a verifiable random.
-func (privKey PrivKey) VRFProve(seed []byte) (crypto.Proof, error) {
- proof, err := vrf.Prove(privKey[:], seed)
+// VRFProve generates a VRF Proof for given message to generate a verifiable random.
+func (privKey PrivKey) VRFProve(message []byte) (crypto.Proof, error) {
+ proof, err := vrf.Prove(privKey[:], message)
  if err != nil {
  return nil, err
  }
@@ -172,14 +173,15 @@ func (pubKey PubKey) Type() string {
  return KeyType
 }
 
-// VRFVerify verifies that the given VRF Proof was generated from the seed by the owner of this public key.
-func (pubKey PubKey) VRFVerify(proof crypto.Proof, seed []byte) (crypto.Output, error) {
- valid, err := vrf.Verify(pubKey[:], vrf.Proof(proof), seed)
+// VRFVerify verifies that the given VRF Proof was generated from the message by the owner of this public key.
+func (pubKey PubKey) VRFVerify(proof crypto.Proof, message []byte) (crypto.Output, error) {
+ valid, err := vrf.Verify(pubKey[:], vrf.Proof(proof), message)
  if err != nil {
- return nil, fmt.Errorf("the specified proof is not a valid ed25519 proof: %v", proof)
+ return nil, fmt.Errorf("the specified proof is not a valid ed25519 proof: err: %s", err.Error())
  }
  if !valid {
- return nil, fmt.Errorf("the specified Proof is not generated with this pair-key: %v", proof)
+ return nil, fmt.Errorf("the specified Proof is not generated with this pair-key: %s",
+ hex.EncodeToString(proof))
  }
  output, err := vrf.ProofToHash(vrf.Proof(proof))
  if err != nil {

crypto/ed25519/ed25519_test.go

@@ -1,6 +1,8 @@
 package ed25519_test
 
 import (
+ "encoding/hex"
+ coniks "github.com/coniks-sys/coniks-go/crypto/vrf"
  "testing"
 
  "github.com/stretchr/testify/assert"
@@ -28,3 +30,41 @@ func TestSignAndValidateEd25519(t *testing.T) {
 
  assert.False(t, pubKey.VerifySignature(msg, sig))
 }
+
+func TestVRFProveAndVRFVerify(t *testing.T) {
+
+ privKey := ed25519.GenPrivKey()
+ pubKey := privKey.PubKey()
+
+ message, _ := hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000000")
+ proof, err := privKey.VRFProve(message)
+ assert.Nil(t, err)
+ assert.NotNil(t, proof)
+
+ output, err := pubKey.VRFVerify(proof, message)
+ assert.Nil(t, err)
+ assert.NotNil(t, output)
+
+ // error
+ {
+ message, _ = hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000001")
+ output, err = pubKey.VRFVerify(proof, message)
+ assert.NotNil(t, err)
+ assert.Nil(t, output)
+ }
+
+ // invalid
+ {
+ privateKey, _ := coniks.GenerateKey(nil)
+ copy(privKey[:], privateKey)
+ pubKey = privKey.PubKey()
+
+ proof, err = privKey.VRFProve(message)
+ assert.Nil(t, err)
+ assert.NotNil(t, proof)
+
+ output, err = pubKey.VRFVerify(proof, message)
+ assert.NotNil(t, err)
+ assert.Nil(t, output)
+ }
+}

crypto/vrf/README.md

@@ -0,0 +1,91 @@
+# VRF
+
+VRF implementation is set by `func init()` with `build` option
+
+## Interface
+* package/file
+ * line/ostracon/crypto/vrf
+ * `var defaultVrf vrfEd25519`
+ * vrf.go
+ * vrf_test.go
+```go
+type vrfEd25519 interface {
+ Prove(privateKey []byte, message []byte) (Proof, error)
+ Verify(publicKey []byte, proof Proof, message []byte) (bool, error)
+ ProofToHash(proof Proof) (Output, error)
+```
+
+## Implementations
+
+Use `func init()` with `build` option
+
+* package/file
+ * line/ostracon/crypto/vrf
+ * (r2ishiguro = default)
+ * `// +build !libsodium,!coniks`
+ * `func init() { defaultVrf = newVrfEd25519r2ishiguro() }`
+ * vrf_r2ishiguro.go
+ * (coniks)
+ * `// +build coniks`
+ * `func init() { defaultVrf = newVrfEd25519coniks() }`
+ * vrf_coniks.go
+ * vrf_coniks_test.go
+ * (libsodium)
+ * `// +build libsodium`
+ * `func init() { defaultVrf = newVrfEd25519libsodium() }`
+ * vrf_libsodium.go
+ * vrf_libsodium_test.go
+
+### Status
+
+| impl | available | memo |
+|:---|:---|:---|
+|r2ishiguro|o|(default)|
+|coniks|x|no compatibility between *crypto ED25519* and *coniks ED25519* (See `TestProveAndVerify_ConiksByCryptoED25519`)|
+|libsodium|o| need to build libsodium (See `libsodium` task of `Makefile`)|
+
+### Attention
+
+* There is no compatibility between *r2ishiguro.Prove/libsodium.Verify* and *libsodium.Prove/r2ishiguro.Verify* (See `TestProveAndVerifyCompatibilityLibsodium`)
+* Ostracon Network should use `r2ishiguro` or `libsodium` (Can't use both at the same time in Ostracon Network)
+
+### libsodium (bind C implementations)
+* package/file
+ * line/ostracon/crypto/vrf/internal/vrf
+ * `// +build libsodium`
+ * vrf.go
+ * vrf_test.go
+ * libsodium: submodule (See `.gitmodule`)
+ * sodium: libs (See `libsodium` task of `Makefile`)
+
+## How to test
+
+```shell
+# r2ishiguro
+go test github.com/line/ostracon/crypto/vrf -tags r2ishiguro
+# libsodium
+go test github.com/line/ostracon/crypto/vrf -tags libsodium
+# internal libsodium only
+go test github.com/line/ostracon/crypto/vrf/internal/vrf -v -tags libsodium
+
+# coniks is not available, but if you want to do, you can see no-compatibility
+go test github.com/line/ostracon/crypto/vrf -tags coniks
+```
+
+## How to benchmark
+
+```shell
+# r2ishiguro
+go test -bench Benchmark github.com/line/ostracon/crypto/vrf -run ^$ -benchtime=1000x -count 10 -benchmem -v
+# libsodium
+go test -bench Benchmark github.com/line/ostracon/crypto/vrf -run ^$ -benchtime=1000x -count 10 -benchmem -v -tags libsodium
+```
+
+## How to build
+
+```shell
+# r2ishiguro
+make build
+# libsodium
+LIBSODIUM=1 make build
+```