mirror/gmsm
1
0
Fork 0
mirror of https://github.com/emmansun/gmsm.git synced 2025-04-27 12:46:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

sm2: fix go1.24 test issue

Browse Source
This commit is contained in:
Sun Yimin 2025-02-26 09:46:03 +08:00 committed by GitHub
parent 2192b702b0
commit ec8580b01f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 120 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
sm2/sm2_dsa_nistp256_test.go Normal file
View File

@ -0,0 +1,120 @@
//go:build !purego && (amd64 || arm64)
package sm2
import (
"bufio"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"testing"
"github.com/emmansun/gmsm/sm3"
)
func TestSignVerifyLegacy(t *testing.T) {
priv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tests := []struct {
name string
plainText string
}{
// TODO: Add test cases.
{"less than 32", "encryption standard"},
{"equals 32", "encryption standard encryption "},
{"long than 32", "encryption standard encryption standard"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
hashed := sm3.Sum([]byte(tt.plainText))
r, s, err := Sign(rand.Reader, priv, hashed[:])
if err != nil {
t.Fatalf("sign failed %v", err)
}
result := Verify(&priv.PublicKey, hashed[:], r, s)
if !result {
t.Fatal("verify failed")
}
hashed[0] ^= 0xff
if Verify(&priv.PublicKey, hashed[:], r, s) {
t.Errorf("VerifyASN1 always works!")
}
})
}
}
func TestSignVerifyWithSM2Legacy(t *testing.T) {
priv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tests := []struct {
name string
plainText string
}{
// TODO: Add test cases.
{"less than 32", "encryption standard"},
{"equals 32", "encryption standard encryption "},
{"long than 32", "encryption standard encryption standard"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r, s, err := SignWithSM2(rand.Reader, priv, nil, []byte(tt.plainText))
if err != nil {
t.Fatalf("sign failed %v", err)
}
result := VerifyWithSM2(&priv.PublicKey, nil, []byte(tt.plainText), r, s)
if !result {
t.Fatal("verify failed")
}
})
}
}
func BenchmarkGenerateKey_P256(b *testing.B) {
r := bufio.NewReaderSize(rand.Reader, 1<<15)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
if _, err := ecdsa.GenerateKey(elliptic.P256(), r); err != nil {
b.Fatal(err)
}
}
}
func BenchmarkSign_P256(b *testing.B) {
r := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := ecdsa.GenerateKey(elliptic.P256(), r)
if err != nil {
b.Fatal(err)
}
hashed := []byte("testing")
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
sig, err := ecdsa.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_P256(b *testing.B) {
rd := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := ecdsa.GenerateKey(elliptic.P256(), rd)
if err != nil {
b.Fatal(err)
}
hashed := []byte("testing")
r, s, err := ecdsa.Sign(rand.Reader, priv, hashed)
if err != nil {
b.Fatal(err)
}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
if !ecdsa.Verify(&priv.PublicKey, hashed, r, s) {
b.Fatal("verify failed")
}
}
}

107
sm2/sm2_dsa_test.go
View File

@ -180,61 +180,6 @@ func TestRecoverPublicKeysFromSM2Signature(t *testing.T) {
} }
} }
func TestSignVerifyLegacy(t *testing.T) {
priv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tests := []struct {
name string
plainText string
}{
// TODO: Add test cases.
{"less than 32", "encryption standard"},
{"equals 32", "encryption standard encryption "},
{"long than 32", "encryption standard encryption standard"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
hashed := sm3.Sum([]byte(tt.plainText))
r, s, err := Sign(rand.Reader, priv, hashed[:])
if err != nil {
t.Fatalf("sign failed %v", err)
}
result := Verify(&priv.PublicKey, hashed[:], r, s)
if !result {
t.Fatal("verify failed")
}
hashed[0] ^= 0xff
if Verify(&priv.PublicKey, hashed[:], r, s) {
t.Errorf("VerifyASN1 always works!")
}
})
}
}
func TestSignVerifyWithSM2Legacy(t *testing.T) {
priv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tests := []struct {
name string
plainText string
}{
// TODO: Add test cases.
{"less than 32", "encryption standard"},
{"equals 32", "encryption standard encryption "},
{"long than 32", "encryption standard encryption standard"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r, s, err := SignWithSM2(rand.Reader, priv, nil, []byte(tt.plainText))
if err != nil {
t.Fatalf("sign failed %v", err)
}
result := VerifyWithSM2(&priv.PublicKey, nil, []byte(tt.plainText), r, s)
if !result {
t.Fatal("verify failed")
}
})
}
}
// Check that signatures remain non-deterministic with a functional entropy source. // Check that signatures remain non-deterministic with a functional entropy source.
func TestINDCCA(t *testing.T) { func TestINDCCA(t *testing.T) {
priv, err := GenerateKey(rand.Reader) priv, err := GenerateKey(rand.Reader)
@ -558,17 +503,6 @@ func BenchmarkGenerateKey_SM2(b *testing.B) {
} }
} }
func BenchmarkGenerateKey_P256(b *testing.B) {
r := bufio.NewReaderSize(rand.Reader, 1<<15)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
if _, err := ecdsa.GenerateKey(elliptic.P256(), r); err != nil {
b.Fatal(err)
}
}
}
func BenchmarkSign_SM2(b *testing.B) { func BenchmarkSign_SM2(b *testing.B) {
r := bufio.NewReaderSize(rand.Reader, 1<<15) r := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := GenerateKey(r) priv, err := GenerateKey(r)
@ -606,47 +540,6 @@ func BenchmarkSign_SM2Specific(b *testing.B) {
}) })
} }
func BenchmarkSign_P256(b *testing.B) {
r := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := ecdsa.GenerateKey(elliptic.P256(), r)
if err != nil {
b.Fatal(err)
}
hashed := []byte("testing")
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
sig, err := ecdsa.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_P256(b *testing.B) {
rd := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := ecdsa.GenerateKey(elliptic.P256(), rd)
if err != nil {
b.Fatal(err)
}
hashed := []byte("testing")
r, s, err := ecdsa.Sign(rand.Reader, priv, hashed)
if err != nil {
b.Fatal(err)
}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
if !ecdsa.Verify(&priv.PublicKey, hashed, r, s) {
b.Fatal("verify failed")
}
}
}
func BenchmarkVerify_SM2(b *testing.B) { func BenchmarkVerify_SM2(b *testing.B) {
rd := bufio.NewReaderSize(rand.Reader, 1<<15) rd := bufio.NewReaderSize(rand.Reader, 1<<15)
priv, err := GenerateKey(rd) priv, err := GenerateKey(rd)