| // Copyright 2011 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. | |
| package ecdsa | |
| import ( | |
| "bufio" | |
| "compress/bzip2" | |
| "crypto/elliptic" | |
| "crypto/rand" | |
| "crypto/sha1" | |
| "crypto/sha256" | |
| "crypto/sha512" | |
| "encoding/hex" | |
| "hash" | |
| "io" | |
| "math/big" | |
| "os" | |
| "strings" | |
| "testing" | |
| ) | |
| func testAllCurves(t *testing.T, f func(*testing.T, elliptic.Curve)) { | |
| tests := []struct { | |
| name string | |
| curve elliptic.Curve | |
| }{ | |
| {"P256", elliptic.P256()}, | |
| {"P224", elliptic.P224()}, | |
| {"P384", elliptic.P384()}, | |
| {"P521", elliptic.P521()}, | |
| } | |
| if testing.Short() { | |
| tests = tests[:1] | |
| } | |
| for _, test := range tests { | |
| curve := test.curve | |
| t.Run(test.name, func(t *testing.T) { | |
| t.Parallel() | |
| f(t, curve) | |
| }) | |
| } | |
| } | |
| func TestKeyGeneration(t *testing.T) { | |
| testAllCurves(t, testKeyGeneration) | |
| } | |
| func testKeyGeneration(t *testing.T, c elliptic.Curve) { | |
| priv, err := GenerateKey(c, rand.Reader) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if !c.IsOnCurve(priv.PublicKey.X, priv.PublicKey.Y) { | |
| t.Errorf("public key invalid: %s", err) | |
| } | |
| } | |
| func TestSignAndVerify(t *testing.T) { | |
| testAllCurves(t, testSignAndVerify) | |
| } | |
| func testSignAndVerify(t *testing.T, c elliptic.Curve) { | |
| priv, _ := GenerateKey(c, rand.Reader) | |
| hashed := []byte("testing") | |
| r, s, err := Sign(rand.Reader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| if !Verify(&priv.PublicKey, hashed, r, s) { | |
| t.Errorf("Verify failed") | |
| } | |
| hashed[0] ^= 0xff | |
| if Verify(&priv.PublicKey, hashed, r, s) { | |
| t.Errorf("Verify always works!") | |
| } | |
| } | |
| func TestSignAndVerifyASN1(t *testing.T) { | |
| testAllCurves(t, testSignAndVerifyASN1) | |
| } | |
| func testSignAndVerifyASN1(t *testing.T, c elliptic.Curve) { | |
| priv, _ := GenerateKey(c, rand.Reader) | |
| hashed := []byte("testing") | |
| sig, err := SignASN1(rand.Reader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| if !VerifyASN1(&priv.PublicKey, hashed, sig) { | |
| t.Errorf("VerifyASN1 failed") | |
| } | |
| hashed[0] ^= 0xff | |
| if VerifyASN1(&priv.PublicKey, hashed, sig) { | |
| t.Errorf("VerifyASN1 always works!") | |
| } | |
| } | |
| func TestNonceSafety(t *testing.T) { | |
| testAllCurves(t, testNonceSafety) | |
| } | |
| func testNonceSafety(t *testing.T, c elliptic.Curve) { | |
| priv, _ := GenerateKey(c, rand.Reader) | |
| hashed := []byte("testing") | |
| r0, s0, err := Sign(zeroReader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| hashed = []byte("testing...") | |
| r1, s1, err := Sign(zeroReader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| if s0.Cmp(s1) == 0 { | |
| // This should never happen. | |
| t.Errorf("the signatures on two different messages were the same") | |
| } | |
| if r0.Cmp(r1) == 0 { | |
| t.Errorf("the nonce used for two different messages was the same") | |
| } | |
| } | |
| func TestINDCCA(t *testing.T) { | |
| testAllCurves(t, testINDCCA) | |
| } | |
| func testINDCCA(t *testing.T, c elliptic.Curve) { | |
| priv, _ := GenerateKey(c, rand.Reader) | |
| hashed := []byte("testing") | |
| r0, s0, err := Sign(rand.Reader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| r1, s1, err := Sign(rand.Reader, priv, hashed) | |
| if err != nil { | |
| t.Errorf("error signing: %s", err) | |
| return | |
| } | |
| if s0.Cmp(s1) == 0 { | |
| t.Errorf("two signatures of the same message produced the same result") | |
| } | |
| if r0.Cmp(r1) == 0 { | |
| t.Errorf("two signatures of the same message produced the same nonce") | |
| } | |
| } | |
| func fromHex(s string) *big.Int { | |
| r, ok := new(big.Int).SetString(s, 16) | |
| if !ok { | |
| panic("bad hex") | |
| } | |
| return r | |
| } | |
| func TestVectors(t *testing.T) { | |
| // This test runs the full set of NIST test vectors from | |
| // https://csrc.nist.gov/groups/STM/cavp/documents/dss/186-3ecdsatestvectors.zip | |
| // | |
| // The SigVer.rsp file has been edited to remove test vectors for | |
| // unsupported algorithms and has been compressed. | |
| if testing.Short() { | |
| return | |
| } | |
| f, err := os.Open("testdata/SigVer.rsp.bz2") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| buf := bufio.NewReader(bzip2.NewReader(f)) | |
| lineNo := 1 | |
| var h hash.Hash | |
| var msg []byte | |
| var hashed []byte | |
| var r, s *big.Int | |
| pub := new(PublicKey) | |
| for { | |
| line, err := buf.ReadString('\n') | |
| if len(line) == 0 { | |
| if err == io.EOF { | |
| break | |
| } | |
| t.Fatalf("error reading from input: %s", err) | |
| } | |
| lineNo++ | |
| // Need to remove \r\n from the end of the line. | |
| if !strings.HasSuffix(line, "\r\n") { | |
| t.Fatalf("bad line ending (expected \\r\\n) on line %d", lineNo) | |
| } | |
| line = line[:len(line)-2] | |
| if len(line) == 0 || line[0] == '#' { | |
| continue | |
| } | |
| if line[0] == '[' { | |
| line = line[1 : len(line)-1] | |
| parts := strings.SplitN(line, ",", 2) | |
| switch parts[0] { | |
| case "P-224": | |
| pub.Curve = elliptic.P224() | |
| case "P-256": | |
| pub.Curve = elliptic.P256() | |
| case "P-384": | |
| pub.Curve = elliptic.P384() | |
| case "P-521": | |
| pub.Curve = elliptic.P521() | |
| default: | |
| pub.Curve = nil | |
| } | |
| switch parts[1] { | |
| case "SHA-1": | |
| h = sha1.New() | |
| case "SHA-224": | |
| h = sha256.New224() | |
| case "SHA-256": | |
| h = sha256.New() | |
| case "SHA-384": | |
| h = sha512.New384() | |
| case "SHA-512": | |
| h = sha512.New() | |
| default: | |
| h = nil | |
| } | |
| continue | |
| } | |
| if h == nil || pub.Curve == nil { | |
| continue | |
| } | |
| switch { | |
| case strings.HasPrefix(line, "Msg = "): | |
| if msg, err = hex.DecodeString(line[6:]); err != nil { | |
| t.Fatalf("failed to decode message on line %d: %s", lineNo, err) | |
| } | |
| case strings.HasPrefix(line, "Qx = "): | |
| pub.X = fromHex(line[5:]) | |
| case strings.HasPrefix(line, "Qy = "): | |
| pub.Y = fromHex(line[5:]) | |
| case strings.HasPrefix(line, "R = "): | |
| r = fromHex(line[4:]) | |
| case strings.HasPrefix(line, "S = "): | |
| s = fromHex(line[4:]) | |
| case strings.HasPrefix(line, "Result = "): | |
| expected := line[9] == 'P' | |
| h.Reset() | |
| h.Write(msg) | |
| hashed := h.Sum(hashed[:0]) | |
| if Verify(pub, hashed, r, s) != expected { | |
| t.Fatalf("incorrect result on line %d", lineNo) | |
| } | |
| default: | |
| t.Fatalf("unknown variable on line %d: %s", lineNo, line) | |
| } | |
| } | |
| } | |
| func TestNegativeInputs(t *testing.T) { | |
| testAllCurves(t, testNegativeInputs) | |
| } | |
| func testNegativeInputs(t *testing.T, curve elliptic.Curve) { | |
| key, err := GenerateKey(curve, rand.Reader) | |
| if err != nil { | |
| t.Errorf("failed to generate key") | |
| } | |
| var hash [32]byte | |
| r := new(big.Int).SetInt64(1) | |
| r.Lsh(r, 550 /* larger than any supported curve */) | |
| r.Neg(r) | |
| if Verify(&key.PublicKey, hash[:], r, r) { | |
| t.Errorf("bogus signature accepted") | |
| } | |
| } | |
| func TestZeroHashSignature(t *testing.T) { | |
| testAllCurves(t, testZeroHashSignature) | |
| } | |
| func testZeroHashSignature(t *testing.T, curve elliptic.Curve) { | |
| zeroHash := make([]byte, 64) | |
| privKey, err := GenerateKey(curve, rand.Reader) | |
| if err != nil { | |
| panic(err) | |
| } | |
| // Sign a hash consisting of all zeros. | |
| r, s, err := Sign(rand.Reader, privKey, zeroHash) | |
| if err != nil { | |
| panic(err) | |
| } | |
| // Confirm that it can be verified. | |
| if !Verify(&privKey.PublicKey, zeroHash, r, s) { | |
| t.Errorf("zero hash signature verify failed for %T", curve) | |
| } | |
| } | |
| func benchmarkAllCurves(t *testing.B, f func(*testing.B, elliptic.Curve)) { | |
| tests := []struct { | |
| name string | |
| curve elliptic.Curve | |
| }{ | |
| {"P256", elliptic.P256()}, | |
| {"P224", elliptic.P224()}, | |
| {"P384", elliptic.P384()}, | |
| {"P521", elliptic.P521()}, | |
| } | |
| for _, test := range tests { | |
| curve := test.curve | |
| t.Run(test.name, func(t *testing.B) { | |
| f(t, curve) | |
| }) | |
| } | |
| } | |
| func BenchmarkSign(b *testing.B) { | |
| benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) { | |
| priv, err := GenerateKey(curve, rand.Reader) | |
| if err != nil { | |
| b.Fatal(err) | |
| } | |
| hashed := []byte("testing") | |
| b.ReportAllocs() | |
| b.ResetTimer() | |
| for i := 0; i < b.N; i++ { | |
| sig, err := SignASN1(rand.Reader, priv, hashed) | |
| if err != nil { | |
| b.Fatal(err) | |
| } | |
| // Prevent the compiler from optimizing out the operation. | |
| hashed[0] = sig[0] | |
| } | |
| }) | |
| } | |
| func BenchmarkVerify(b *testing.B) { | |
| benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) { | |
| priv, err := GenerateKey(curve, rand.Reader) | |
| if err != nil { | |
| b.Fatal(err) | |
| } | |
| hashed := []byte("testing") | |
| r, s, err := Sign(rand.Reader, priv, hashed) | |
| if err != nil { | |
| b.Fatal(err) | |
| } | |
| b.ReportAllocs() | |
| b.ResetTimer() | |
| for i := 0; i < b.N; i++ { | |
| if !Verify(&priv.PublicKey, hashed, r, s) { | |
| b.Fatal("verify failed") | |
| } | |
| } | |
| }) | |
| } | |
| func BenchmarkGenerateKey(b *testing.B) { | |
| benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) { | |
| b.ReportAllocs() | |
| b.ResetTimer() | |
| for i := 0; i < b.N; i++ { | |
| if _, err := GenerateKey(curve, rand.Reader); err != nil { | |
| b.Fatal(err) | |
| } | |
| } | |
| }) | |
| } |