gitee.com/lh-her-team/common@v1.5.1/crypto/asym/ecdsa/sk.go (about)

     1  package ecdsa
     2  
     3  import (
     4  	"bytes"
     5  	crypto2 "crypto"
     6  	"crypto/ecdsa"
     7  	"crypto/elliptic"
     8  	"crypto/rand"
     9  	"crypto/x509"
    10  	"encoding/asn1"
    11  	"encoding/hex"
    12  	"encoding/pem"
    13  	"fmt"
    14  	"math/big"
    15  
    16  	"gitee.com/lh-her-team/common/crypto"
    17  	"gitee.com/lh-her-team/common/crypto/hash"
    18  	"github.com/btcsuite/btcd/btcec"
    19  )
    20  
    21  type PrivateKey struct {
    22  	K *ecdsa.PrivateKey
    23  }
    24  
    25  type Sig struct {
    26  	R *big.Int `json:"r"`
    27  	S *big.Int `json:"s"`
    28  }
    29  
    30  func (sk *PrivateKey) Bytes() ([]byte, error) {
    31  	if sk.K == nil {
    32  		return nil, fmt.Errorf("private key is nil")
    33  	}
    34  	if sk.Type() == crypto.ECC_Secp256k1 {
    35  		rawKey := (*btcec.PrivateKey)(sk.K).Serialize()
    36  		return rawKey, nil
    37  	}
    38  	return x509.MarshalECPrivateKey(sk.K)
    39  }
    40  
    41  func (sk *PrivateKey) PublicKey() crypto.PublicKey {
    42  	return &PublicKey{K: &sk.K.PublicKey}
    43  }
    44  
    45  func (sk *PrivateKey) Sign(digest []byte) ([]byte, error) {
    46  	var (
    47  		r, s *big.Int
    48  		err  error
    49  	)
    50  	r, s, err = ecdsa.Sign(rand.Reader, sk.K, digest[:])
    51  	if err != nil {
    52  		return nil, err
    53  	}
    54  	return asn1.Marshal(Sig{R: r, S: s})
    55  }
    56  
    57  func (sk *PrivateKey) SignWithOpts(msg []byte, opts *crypto.SignOpts) ([]byte, error) {
    58  	if opts == nil {
    59  		return sk.Sign(msg)
    60  	}
    61  	dgst, err := hash.Get(opts.Hash, msg)
    62  	if err != nil {
    63  		return nil, err
    64  	}
    65  	return sk.Sign(dgst)
    66  }
    67  
    68  func (sk *PrivateKey) Type() crypto.KeyType {
    69  	return sk.PublicKey().Type()
    70  }
    71  
    72  func (sk *PrivateKey) String() (string, error) {
    73  	skDER, err := sk.Bytes()
    74  	if err != nil {
    75  		return "", err
    76  	}
    77  	if sk.Type() == crypto.ECC_Secp256k1 {
    78  		return hex.EncodeToString(skDER), nil
    79  	}
    80  	block := &pem.Block{
    81  		Type:  "EC PRIVATE KEY",
    82  		Bytes: skDER,
    83  	}
    84  	buf := new(bytes.Buffer)
    85  	if err = pem.Encode(buf, block); err != nil {
    86  		return "", err
    87  	}
    88  	return buf.String(), nil
    89  }
    90  
    91  func (sk *PrivateKey) ToStandardKey() crypto2.PrivateKey {
    92  	return sk.K
    93  }
    94  
    95  func New(keyType crypto.KeyType) (crypto.PrivateKey, error) {
    96  	switch keyType {
    97  	case crypto.ECC_Secp256k1:
    98  		pri, err := ecdsa.GenerateKey(btcec.S256(), rand.Reader)
    99  		if err != nil {
   100  			return nil, err
   101  		}
   102  		return &PrivateKey{K: pri}, nil
   103  	case crypto.ECC_NISTP256:
   104  		pri, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
   105  		if err != nil {
   106  			return nil, err
   107  		}
   108  		return &PrivateKey{K: pri}, nil
   109  	case crypto.ECC_NISTP384:
   110  		pri, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
   111  		if err != nil {
   112  			return nil, err
   113  		}
   114  		return &PrivateKey{K: pri}, nil
   115  	case crypto.ECC_NISTP521:
   116  		pri, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
   117  		if err != nil {
   118  			return nil, err
   119  		}
   120  		return &PrivateKey{K: pri}, nil
   121  	}
   122  	return nil, fmt.Errorf("wrong curve option")
   123  }