139 lines
2.8 KiB
Go
139 lines
2.8 KiB
Go
package util
|
|
|
|
import (
|
|
"PaymentCenter/app/third/paymentService/psbc/internal/gmutil/sm2/model"
|
|
"bytes"
|
|
"encoding/hex"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"math/big"
|
|
)
|
|
|
|
func JoinBytes(params ...[]byte) ([]byte, error) {
|
|
var buffer bytes.Buffer
|
|
for i := 0; i < len(params); i++ {
|
|
_, err := buffer.Write(params[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return buffer.Bytes(), nil
|
|
}
|
|
|
|
func HexToPrivateKey(d []byte) (*model.PrivateKey, error) {
|
|
k := new(big.Int).SetBytes(d)
|
|
c := NewP256Sm2()
|
|
params := c.Params()
|
|
n := new(big.Int).Sub(params.N, model.One)
|
|
if k.Cmp(n) >= 0 {
|
|
return nil, fmt.Errorf("privateKey is overflow")
|
|
}
|
|
pri := &model.PrivateKey{
|
|
PublicKey: &model.PublicKey{},
|
|
D: nil,
|
|
}
|
|
pri.PublicKey.Curve = c
|
|
pri.D = k
|
|
pri.PublicKey.X, pri.PublicKey.Y = c.ScalarBaseMult(k.Bytes())
|
|
return pri, nil
|
|
}
|
|
|
|
func HexToPublicKey(d []byte) (*model.PublicKey, error) {
|
|
if len(d) == 65 && d[0] == byte(0x04) {
|
|
d = d[1:]
|
|
}
|
|
if len(d) != 64 {
|
|
return nil, fmt.Errorf("publicKey is not 64 bytes: %d", len(d))
|
|
}
|
|
pub := new(model.PublicKey)
|
|
pub.Curve = NewP256Sm2()
|
|
pub.X = new(big.Int).SetBytes(d[:32])
|
|
pub.Y = new(big.Int).SetBytes(d[32:])
|
|
return pub, nil
|
|
}
|
|
|
|
func PrivateKeyToPem(key *model.PrivateKey, pwd []byte) ([]byte, error) {
|
|
var block *pem.Block
|
|
der, err := MarshalSm2PrivateKey(key, pwd) //Convert private key to DER format
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pwd != nil {
|
|
block = &pem.Block{
|
|
Type: "ENCRYPTED PRIVATE KEY",
|
|
Bytes: der,
|
|
}
|
|
} else {
|
|
block = &pem.Block{
|
|
Type: "PRIVATE KEY",
|
|
Bytes: der,
|
|
}
|
|
}
|
|
certPem := pem.EncodeToMemory(block)
|
|
return certPem, nil
|
|
}
|
|
|
|
func PublicKeyToPem(key *model.PublicKey) ([]byte, error) {
|
|
der, err := MarshalSm2PublicKey(key) //Convert publick key to DER format
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
block := &pem.Block{
|
|
Type: "PUBLIC KEY",
|
|
Bytes: der,
|
|
}
|
|
certPem := pem.EncodeToMemory(block)
|
|
return certPem, nil
|
|
}
|
|
|
|
func PrivateKeyToHex(key *model.PrivateKey) string {
|
|
return key.D.Text(16)
|
|
}
|
|
|
|
func PublicKeyToHex(key *model.PublicKey) string {
|
|
x := key.X.Bytes()
|
|
y := key.Y.Bytes()
|
|
if n := len(x); n < 32 {
|
|
x = append(zeroByteSlice()[:32-n], x...)
|
|
}
|
|
if n := len(y); n < 32 {
|
|
y = append(zeroByteSlice()[:32-n], y...)
|
|
}
|
|
var c []byte
|
|
c = append(c, x...)
|
|
c = append(c, y...)
|
|
c = append([]byte{0x04}, c...)
|
|
return hex.EncodeToString(c)
|
|
}
|
|
|
|
// 32byte
|
|
func zeroByteSlice() []byte {
|
|
return []byte{
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
}
|
|
}
|
|
|
|
func HexToSignature(hexStr string) (s model.Signature, err error) {
|
|
signData, err := hex.DecodeString(hexStr)
|
|
if err != nil {
|
|
return
|
|
}
|
|
rBy := make([]byte, 33)
|
|
copy(rBy[1:], signData[:32])
|
|
rBy[0] = 0x00
|
|
s.R = new(big.Int).SetBytes(rBy)
|
|
|
|
sBy := make([]byte, 33)
|
|
copy(sBy[1:], signData[32:64])
|
|
sBy[0] = 0x00
|
|
s.S = new(big.Int).SetBytes(sBy)
|
|
return
|
|
}
|