remove util.go

internal/randutil/randutil.go

@@ -0,0 +1,38 @@
+// Copyright 2018 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 randutil contains internal randomness utilities for various
+// crypto packages.
+package randutil
+
+import (
+	"io"
+	"sync"
+)
+
+var (
+	closedChanOnce sync.Once
+	closedChan     chan struct{}
+)
+
+// MaybeReadByte reads a single byte from r with ~50% probability. This is used
+// to ensure that callers do not depend on non-guaranteed behaviour, e.g.
+// assuming that rsa.GenerateKey is deterministic w.r.t. a given random stream.
+//
+// This does not affect tests that pass a stream of fixed bytes as the random
+// source (e.g. a zeroReader).
+func MaybeReadByte(r io.Reader) {
+	closedChanOnce.Do(func() {
+		closedChan = make(chan struct{})
+		close(closedChan)
+	})
+
+	select {
+	case <-closedChan:
+		return
+	case <-closedChan:
+		var buf [1]byte
+		r.Read(buf[:])
+	}
+}

sm2/sm2.go

@@ -24,6 +24,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/emmansun/gmsm/internal/randutil"
 	"github.com/emmansun/gmsm/sm3"
 	"golang.org/x/crypto/cryptobyte"
 	"golang.org/x/crypto/cryptobyte/asn1"
@@ -113,6 +114,50 @@ func (mode pointMarshalMode) mashal(curve elliptic.Curve, x, y *big.Int) []byte
 	}
 }
 
+func toBytes(curve elliptic.Curve, value *big.Int) []byte {
+	byteLen := (curve.Params().BitSize + 7) >> 3
+	result := make([]byte, byteLen)
+	value.FillBytes(result[:])
+	return result
+}
+
+func bytes2Point(curve elliptic.Curve, bytes []byte) (*big.Int, *big.Int, int, error) {
+	if len(bytes) < 1+(curve.Params().BitSize/8) {
+		return nil, nil, 0, fmt.Errorf("invalid bytes length %d", len(bytes))
+	}
+	format := bytes[0]
+	byteLen := (curve.Params().BitSize + 7) >> 3
+	switch format {
+	case uncompressed, mixed06, mixed07: // what's the mixed format purpose?
+		if len(bytes) < 1+byteLen*2 {
+			return nil, nil, 0, fmt.Errorf("invalid uncompressed bytes length %d", len(bytes))
+		}
+		data := make([]byte, 1+byteLen*2)
+		data[0] = uncompressed
+		copy(data[1:], bytes[1:1+byteLen*2])
+		x, y := elliptic.Unmarshal(curve, data)
+		if x == nil || y == nil {
+			return nil, nil, 0, fmt.Errorf("point is not on curve %s", curve.Params().Name)
+		}
+		return x, y, 1 + byteLen*2, nil
+	case compressed02, compressed03:
+		if len(bytes) < 1+byteLen {
+			return nil, nil, 0, fmt.Errorf("invalid compressed bytes length %d", len(bytes))
+		}
+		// Make sure it's NIST curve or SM2 P-256 curve
+		if strings.HasPrefix(curve.Params().Name, "P-") || strings.EqualFold(curve.Params().Name, p256.CurveParams.Name) {
+			// y² = x³ - 3x + b, prime curves
+			x, y := elliptic.UnmarshalCompressed(curve, bytes[:1+byteLen])
+			if x == nil || y == nil {
+				return nil, nil, 0, fmt.Errorf("point is not on curve %s", curve.Params().Name)
+			}
+			return x, y, 1 + byteLen, nil
+		}
+		return nil, nil, 0, fmt.Errorf("unsupport bytes format %d, curve %s", format, curve.Params().Name)
+	}
+	return nil, nil, 0, fmt.Errorf("unknown bytes format %d", format)
+}
+
 var defaultEncrypterOpts = &EncrypterOpts{ENCODING_PLAIN, MarshalUncompressed, C1C3C2}
 
 var ASN1EncrypterOpts = &EncrypterOpts{ENCODING_ASN1, MarshalUncompressed, C1C3C2}
@@ -588,7 +633,7 @@ func fermatInverse(k, N *big.Int) *big.Int {
 //
 // Compliance with GB/T 32918.2-2016 regardless it's SM2 curve or not.
 func Sign(rand io.Reader, priv *ecdsa.PrivateKey, hash []byte) (r, s *big.Int, err error) {
-	maybeReadByte(rand)
+	randutil.MaybeReadByte(rand)
 
 	// We use SDK's nouce generation implementation here.
 	//

sm2/util.go

@@ -1,80 +0,0 @@
-package sm2
-
-import (
-	"crypto/elliptic"
-	"fmt"
-	"io"
-	"math/big"
-	"strings"
-	"sync"
-)
-
-func toBytes(curve elliptic.Curve, value *big.Int) []byte {
-	byteLen := (curve.Params().BitSize + 7) >> 3
-	result := make([]byte, byteLen)
-	value.FillBytes(result)
-	return result
-}
-
-func bytes2Point(curve elliptic.Curve, bytes []byte) (*big.Int, *big.Int, int, error) {
-	if len(bytes) < 1+(curve.Params().BitSize/8) {
-		return nil, nil, 0, fmt.Errorf("invalid bytes length %d", len(bytes))
-	}
-	format := bytes[0]
-	byteLen := (curve.Params().BitSize + 7) >> 3
-	switch format {
-	case uncompressed, mixed06, mixed07: // what's the mixed format purpose?
-		if len(bytes) < 1+byteLen*2 {
-			return nil, nil, 0, fmt.Errorf("invalid uncompressed bytes length %d", len(bytes))
-		}
-		data := make([]byte, 1+byteLen*2)
-		data[0] = uncompressed
-		copy(data[1:], bytes[1:1+byteLen*2])
-		x, y := elliptic.Unmarshal(curve, data)
-		if x == nil || y == nil {
-			return nil, nil, 0, fmt.Errorf("point is not on curve %s", curve.Params().Name)
-		}
-		return x, y, 1 + byteLen*2, nil
-	case compressed02, compressed03:
-		if len(bytes) < 1+byteLen {
-			return nil, nil, 0, fmt.Errorf("invalid compressed bytes length %d", len(bytes))
-		}
-		// Make sure it's NIST curve or SM2 P-256 curve
-		if strings.HasPrefix(curve.Params().Name, "P-") || strings.EqualFold(curve.Params().Name, p256.CurveParams.Name) {
-			// y² = x³ - 3x + b, prime curves
-			x, y := elliptic.UnmarshalCompressed(curve, bytes[:1+byteLen])
-			if x == nil || y == nil {
-				return nil, nil, 0, fmt.Errorf("point is not on curve %s", curve.Params().Name)
-			}
-			return x, y, 1 + byteLen, nil
-		}
-		return nil, nil, 0, fmt.Errorf("unsupport bytes format %d, curve %s", format, curve.Params().Name)
-	}
-	return nil, nil, 0, fmt.Errorf("unknown bytes format %d", format)
-}
-
-var (
-	closedChanOnce sync.Once
-	closedChan     chan struct{}
-)
-
-// maybeReadByte reads a single byte from r with ~50% probability. This is used
-// to ensure that callers do not depend on non-guaranteed behaviour, e.g.
-// assuming that rsa.GenerateKey is deterministic w.r.t. a given random stream.
-//
-// This does not affect tests that pass a stream of fixed bytes as the random
-// source (e.g. a zeroReader).
-func maybeReadByte(r io.Reader) {
-	closedChanOnce.Do(func() {
-		closedChan = make(chan struct{})
-		close(closedChan)
-	})
-
-	select {
-	case <-closedChan:
-		return
-	case <-closedChan:
-		var buf [1]byte
-		r.Read(buf[:])
-	}
-}

sm2/util_test.go

@@ -1,32 +0,0 @@
-package sm2
-
-import (
-	"crypto/elliptic"
-	"encoding/hex"
-	"math/big"
-	"reflect"
-	"testing"
-)
-
-func Test_toBytes(t *testing.T) {
-	type args struct {
-		value string
-	}
-	tests := []struct {
-		name string
-		args args
-		want string
-	}{
-		// TODO: Add test cases.
-		{"less than 32", args{"d20d27d0632957f8028c1e024f6b02edf23102a566c932ae8bd613a8e865fe"}, "00d20d27d0632957f8028c1e024f6b02edf23102a566c932ae8bd613a8e865fe"},
-		{"equals 32", args{"58d20d27d0632957f8028c1e024f6b02edf23102a566c932ae8bd613a8e865fe"}, "58d20d27d0632957f8028c1e024f6b02edf23102a566c932ae8bd613a8e865fe"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v, _ := new(big.Int).SetString(tt.args.value, 16)
-			if got := toBytes(elliptic.P256(), v); !reflect.DeepEqual(hex.EncodeToString(got), tt.want) {
-				t.Errorf("toBytes() = %v, want %v", hex.EncodeToString(got), tt.want)
-			}
-		})
-	}
-}