Merge pull request #201 from Bytom/v0.1

[bytom/vapor.git] / vendor / github.com / bytom / crypto / ed25519 / ed25519_test.go

diff --git a/vendor/github.com/bytom/crypto/ed25519/ed25519_test.go b/vendor/github.com/bytom/crypto/ed25519/ed25519_test.go
new file mode 100644 (file)
index 0000000..e0d5a1d
--- /dev/null
+++ b/vendor/github.com/bytom/crypto/ed25519/ed25519_test.go
@@ -0,0 +1,155 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file at
+// https://github.com/golang/crypto/blob/master/LICENSE.
+
+package ed25519
+
+import (
+       "bufio"
+       "bytes"
+       "compress/gzip"
+       "crypto/rand"
+       "encoding/hex"
+       "os"
+       "strings"
+       "testing"
+
+       "github.com/bytom/crypto/ed25519/internal/edwards25519"
+)
+
+type zeroReader struct{}
+
+func (zeroReader) Read(buf []byte) (int, error) {
+       for i := range buf {
+               buf[i] = 0
+       }
+       return len(buf), nil
+}
+
+func TestUnmarshalMarshal(t *testing.T) {
+       pub, _, _ := GenerateKey(rand.Reader)
+
+       var A edwards25519.ExtendedGroupElement
+       var pubBytes [32]byte
+       copy(pubBytes[:], pub)
+       if !A.FromBytes(&pubBytes) {
+               t.Fatalf("ExtendedGroupElement.FromBytes failed")
+       }
+
+       var pub2 [32]byte
+       A.ToBytes(&pub2)
+
+       if pubBytes != pub2 {
+               t.Errorf("FromBytes(%v)->ToBytes does not round-trip, got %x\n", pubBytes, pub2)
+       }
+}
+
+func TestSignVerify(t *testing.T) {
+       var zero zeroReader
+       public, private, _ := GenerateKey(zero)
+
+       message := []byte("test message")
+       sig := Sign(private, message)
+       if !Verify(public, message, sig) {
+               t.Errorf("valid signature rejected")
+       }
+
+       wrongMessage := []byte("wrong message")
+       if Verify(public, wrongMessage, sig) {
+               t.Errorf("signature of different message accepted")
+       }
+}
+
+func TestGolden(t *testing.T) {
+       // sign.input.gz is a selection of test cases from
+       // http://ed25519.cr.yp.to/python/sign.input
+       testDataZ, err := os.Open("testdata/sign.input.gz")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer testDataZ.Close()
+       testData, err := gzip.NewReader(testDataZ)
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer testData.Close()
+
+       scanner := bufio.NewScanner(testData)
+       lineNo := 0
+
+       for scanner.Scan() {
+               lineNo++
+
+               line := scanner.Text()
+               parts := strings.Split(line, ":")
+               if len(parts) != 5 {
+                       t.Fatalf("bad number of parts on line %d", lineNo)
+               }
+
+               privBytes, _ := hex.DecodeString(parts[0])
+               pubKey, _ := hex.DecodeString(parts[1])
+               msg, _ := hex.DecodeString(parts[2])
+               sig, _ := hex.DecodeString(parts[3])
+               // The signatures in the test vectors also include the message
+               // at the end, but we just want R and S.
+               sig = sig[:SignatureSize]
+
+               if l := len(pubKey); l != PublicKeySize {
+                       t.Fatalf("bad public key length on line %d: got %d bytes", lineNo, l)
+               }
+
+               var priv [PrivateKeySize]byte
+               copy(priv[:], privBytes)
+               copy(priv[32:], pubKey)
+
+               sig2 := Sign(priv[:], msg)
+               if !bytes.Equal(sig, sig2[:]) {
+                       t.Errorf("different signature result on line %d: %x vs %x", lineNo, sig, sig2)
+               }
+
+               if !Verify(pubKey, msg, sig2) {
+                       t.Errorf("signature failed to verify on line %d", lineNo)
+               }
+       }
+
+       if err := scanner.Err(); err != nil {
+               t.Fatalf("error reading test data: %s", err)
+       }
+}
+
+func BenchmarkKeyGeneration(b *testing.B) {
+       var zero zeroReader
+       for i := 0; i < b.N; i++ {
+               if _, _, err := GenerateKey(zero); err != nil {
+                       b.Fatal(err)
+               }
+       }
+}
+
+func BenchmarkSigning(b *testing.B) {
+       var zero zeroReader
+       _, priv, err := GenerateKey(zero)
+       if err != nil {
+               b.Fatal(err)
+       }
+       message := []byte("Hello, world!")
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Sign(priv, message)
+       }
+}
+
+func BenchmarkVerification(b *testing.B) {
+       var zero zeroReader
+       pub, priv, err := GenerateKey(zero)
+       if err != nil {
+               b.Fatal(err)
+       }
+       message := []byte("Hello, world!")
+       signature := Sign(priv, message)
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               Verify(pub, message, signature)
+       }
+}