Improve vrf test (#403)

* Imporve using require

* Improve using require and leave the comment for TestAvalancheEffect

* Refactor separate into compatibility test

* Add hdevalence/ed25519consensus

* (fxiup) Update the function name with the camel case

crypto/vrf/compatibility_keys_test.go

@@ -0,0 +1,210 @@
+//go:build libsodium
+// +build libsodium
+
+package vrf
+
+import (
+ "bytes"
+ "crypto/ed25519"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ coniks "github.com/coniks-sys/coniks-go/crypto/vrf"
+ ed25519consensus "github.com/hdevalence/ed25519consensus"
+ libsodium "github.com/line/ostracon/crypto/vrf/internal/vrf"
+ xed25519 "golang.org/x/crypto/ed25519"
+)
+
+var secret [SEEDBYTES]byte
+var message []byte = []byte("hello, world")
+
+func TestKeygen(t *testing.T) {
+ for i := 0; i < SEEDBYTES; i++ {
+ secret[i] = uint8(i)
+ }
+ privateKey, publicKey := keygenByEd25519(secret)
+
+ t.Run("ed25519 and x/ed25519 have compatibility",
+ func(t *testing.T) {
+ testKeygenCompatibility(t, privateKey, publicKey,
+ keygenByXed25519, require.Equal, require.Equal)
+ })
+ t.Run("ed25519 and coniks have NOT compatibility",
+ func(t *testing.T) {
+ testKeygenCompatibility(t, privateKey, publicKey,
+ keygenByConiksEd25519, require.NotEqual, require.NotEqual)
+ })
+ t.Run("ed25519 and libsodium have compatibility",
+ func(t *testing.T) {
+ testKeygenCompatibility(t, privateKey, publicKey,
+ keygenByLibsodiumEd25519, require.Equal, require.Equal)
+ })
+}
+
+func testKeygenCompatibility(
+ t *testing.T,
+ sk1 ed25519.PrivateKey, pk1 ed25519.PublicKey,
+ keyGen2 func(secret [SEEDBYTES]byte) (ed25519.PrivateKey, ed25519.PublicKey),
+ skTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+ pkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+) {
+ sk2, pk2 := keyGen2(secret)
+ skTest(t, sk1, sk2)
+ pkTest(t, pk1, pk2)
+}
+
+func keygenByEd25519(secret [SEEDBYTES]byte) (ed25519.PrivateKey, ed25519.PublicKey) {
+ privateKey := ed25519.NewKeyFromSeed(secret[:])
+ publicKey := privateKey.Public().(ed25519.PublicKey)
+ return privateKey, publicKey
+}
+
+func keygenByXed25519(secret [SEEDBYTES]byte) (ed25519.PrivateKey, ed25519.PublicKey) {
+ publicKey, privateKey, _ := xed25519.GenerateKey(bytes.NewReader(secret[:]))
+ return privateKey, publicKey
+}
+
+func keygenByConiksEd25519(secret [SEEDBYTES]byte) (ed25519.PrivateKey, ed25519.PublicKey) {
+ privKey, _ := coniks.GenerateKey(bytes.NewReader(secret[:]))
+ pubKey, _ := privKey.Public()
+ privateKey := make([]byte, coniks.PrivateKeySize)
+ copy(privateKey, privKey[:])
+ publicKey := make([]byte, coniks.PublicKeySize)
+ copy(publicKey, pubKey[:])
+ return privateKey, publicKey
+}
+
+func keygenByLibsodiumEd25519(secret [SEEDBYTES]byte) (ed25519.PrivateKey, ed25519.PublicKey) {
+ var seed [libsodium.SEEDBYTES]byte
+ copy(seed[:], secret[:])
+ pubKey, privKey := libsodium.KeyPairFromSeed(&seed)
+ privateKey := make([]byte, libsodium.SECRETKEYBYTES)
+ copy(privateKey, privKey[:])
+ publicKey := make([]byte, libsodium.PUBLICKEYBYTES)
+ copy(publicKey, pubKey[:])
+ return privateKey, publicKey
+}
+
+func TestKeypair(t *testing.T) {
+ privateKey, publicKey := keygenByEd25519(secret)
+
+ t.Run("ed25519 and x/ed25519 have compatibility",
+ func(t *testing.T) {
+ testKeypairCompatibilityWithXed25519(t, privateKey, publicKey,
+ require.EqualValues, require.EqualValues)
+ })
+ t.Run("ed25519 and coniks have NOT compatibility",
+ func(t *testing.T) {
+ testKeypairCompatibilityWithConiksEd25519(t, privateKey, publicKey,
+ require.EqualValues, require.NotEqualValues)
+ })
+ t.Run("ed25519 and libsodium have compatibility",
+ func(t *testing.T) {
+ testKeypairCompatibilityWithLibsodiumEd25519(t, privateKey, publicKey,
+ require.EqualValues, require.EqualValues)
+ })
+}
+
+func testKeypairCompatibilityWithXed25519(
+ t *testing.T,
+ sk ed25519.PrivateKey, pk ed25519.PublicKey,
+ toPkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+ fromSkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+) {
+ pk1, sk1, _ := xed25519.GenerateKey(bytes.NewReader(secret[:]))
+
+ sk2 := ed25519.PrivateKey(make([]byte, ed25519.PrivateKeySize))
+ copy(sk2[:], sk1[:])
+ pk2 := sk2.Public().(ed25519.PublicKey)
+
+ toPkTest(t, pk1[:], pk2[:])
+
+ copy(sk1[:], sk[:])
+ pk1 = sk1.Public().(xed25519.PublicKey)
+
+ fromSkTest(t, pk1[:], pk2[:])
+}
+
+func testKeypairCompatibilityWithConiksEd25519(
+ t *testing.T,
+ sk ed25519.PrivateKey, pk ed25519.PublicKey,
+ toPkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+ fromSkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+) {
+ sk1, _ := coniks.GenerateKey(bytes.NewReader(secret[:]))
+ pk1, _ := sk1.Public()
+
+ sk2 := ed25519.PrivateKey(make([]byte, ed25519.PrivateKeySize))
+ copy(sk2[:], sk1[:])
+ pk2 := sk2.Public().(ed25519.PublicKey)
+
+ toPkTest(t, pk1[:], pk2[:])
+
+ copy(sk1[:], sk[:])
+ pk1, _ = sk1.Public()
+
+ fromSkTest(t, pk1[:], pk2[:])
+}
+
+func testKeypairCompatibilityWithLibsodiumEd25519(
+ t *testing.T,
+ sk ed25519.PrivateKey, pk ed25519.PublicKey,
+ toPkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+ fromSkTest func(t require.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}),
+) {
+ var seed [libsodium.SEEDBYTES]byte
+ copy(seed[:], secret[:])
+ pk1, sk1 := libsodium.KeyPairFromSeed(&seed)
+
+ sk2 := ed25519.PrivateKey(make([]byte, ed25519.PrivateKeySize))
+ copy(sk2[:], sk1[:])
+ pk2 := sk2.Public().(ed25519.PublicKey)
+
+ toPkTest(t, pk1[:], pk2[:])
+
+ copy(sk1[:], sk[:])
+ pk1 = libsodium.SkToPk(sk1)
+
+ fromSkTest(t, pk1[:], pk2[:])
+}
+
+func TestSignVerify(t *testing.T) {
+ sk, pk := keygenByEd25519(secret)
+ t.Run("ed25519( and ed25519consensus.Verify) and xed25119 have compatibility", func(t *testing.T) {
+ pk1, sk1, _ := xed25519.GenerateKey(bytes.NewReader(secret[:]))
+
+ signature := ed25519.Sign(sk, message)
+ valid := xed25519.Verify(pk1, message, signature)
+ assert.True(t, valid)
+
+ signature = xed25519.Sign(sk1, message)
+ valid = ed25519.Verify(pk, message, signature)
+ assert.True(t, valid)
+
+ valid = ed25519consensus.Verify(pk, message, signature)
+ assert.True(t, valid)
+ })
+}
+
+func BenchmarkKeyGenByEd25519(b *testing.B) {
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ keygenByEd25519(secret)
+ }
+}
+
+func BenchmarkKeyGenByConiksEd25519(b *testing.B) {
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ keygenByConiksEd25519(secret)
+ }
+}
+
+func BenchmarkKeyGenByLibsodiumEd25519(b *testing.B) {
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ keygenByLibsodiumEd25519(secret)
+ }
+}

crypto/vrf/compatibility_vrf_test.go

@@ -0,0 +1,44 @@
+//go:build libsodium
+// +build libsodium
+
+package vrf
+
+import (
+ "crypto/ed25519"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ r2ishiguro "github.com/r2ishiguro/vrf/go/vrf_ed25519"
+)
+
+func TestProveAndVerifyCompatibility(t *testing.T) {
+ privateKey := ed25519.NewKeyFromSeed(secret[:])
+ publicKey := privateKey.Public().(ed25519.PublicKey)
+
+ sk := make([]byte, ed25519.PrivateKeySize)
+ copy(sk, privateKey[:])
+ pk := make([]byte, ed25519.PublicKeySize)
+ copy(pk, publicKey[:])
+
+ libsodiumImpl := newVrfEd25519libsodium()
+
+ t.Run("libsodium.Prove and r2ishiguro.Verify have NOT compatibility", func(t *testing.T) {
+ proof, err := libsodiumImpl.Prove(sk, message)
+ require.NoError(t, err)
+ require.NotNil(t, proof)
+
+ valid, err := r2ishiguro.ECVRF_verify(pk, proof, message)
+ require.Error(t, err)
+ require.False(t, valid)
+ })
+ t.Run("r2ishiguro.Prove and libsodium.Verify have NOT compatibility", func(t *testing.T) {
+ proof, err := r2ishiguro.ECVRF_prove(pk, sk, message)
+ require.NoError(t, err)
+ require.NotNil(t, proof)
+
+ valid, err := libsodiumImpl.Verify(pk, proof, message)
+ require.Error(t, err)
+ require.False(t, valid)
+ })
+}