加密调整
This commit is contained in:
李子铭
parent
721808e543
commit
2af26fb728
|
|
@ -1,19 +0,0 @@
|
|||
package cmb
|
||||
|
||||
import (
|
||||
sm22 "voucher/internal/pkg/cmb/sm2"
|
||||
)
|
||||
|
||||
type Smx struct {
|
||||
Sm *sm22.Sm2
|
||||
}
|
||||
|
||||
func NewSmx(privateKey, publicKey string) (*Smx, error) {
|
||||
return &Smx{
|
||||
Sm: sm22.NewSm2().SetHexPrivateKey(privateKey).SetHexPublicKey(publicKey),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *Smx) Sign(input string) {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"crypto/elliptic"
|
||||
"math/big"
|
||||
)
|
||||
|
||||
var (
|
||||
One = new(big.Int).SetInt64(1)
|
||||
DefaultUid = []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}
|
||||
VerifyFalse = []byte{0x30}
|
||||
VerifyTrue = []byte{0x31}
|
||||
)
|
||||
|
||||
type CipherType int32
|
||||
|
||||
const (
|
||||
C1C2C3 CipherType = 1
|
||||
C1C3C2 CipherType = 2
|
||||
)
|
||||
|
||||
type PublicKey struct {
|
||||
elliptic.Curve
|
||||
X, Y *big.Int
|
||||
}
|
||||
|
||||
type PrivateKey struct {
|
||||
*PublicKey
|
||||
D *big.Int
|
||||
}
|
||||
|
||||
type Signature struct {
|
||||
R, S *big.Int
|
||||
}
|
||||
|
|
@ -0,0 +1,387 @@
|
|||
package cmbv2
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"encoding/asn1"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"github.com/ZZMarquis/gm/sm4"
|
||||
"io"
|
||||
"math/big"
|
||||
"strings"
|
||||
"voucher/internal/pkg/cmb/sm2/sdk"
|
||||
"voucher/internal/pkg/cmbv2/model"
|
||||
"voucher/internal/pkg/cmbv2/utils"
|
||||
)
|
||||
|
||||
type Cmb struct {
|
||||
publicKey *model.PublicKey
|
||||
privateKey *model.PrivateKey
|
||||
|
||||
cipherType model.CipherType
|
||||
c3Len int
|
||||
uid []byte
|
||||
|
||||
sdk sdk.SDK
|
||||
|
||||
sm2P256 *utils.Sm2P256Curve
|
||||
}
|
||||
|
||||
func NewCmb(privateKey, sopPublicKey string) (*Cmb, error) {
|
||||
cmb := &Cmb{
|
||||
c3Len: 32,
|
||||
uid: model.DefaultUid,
|
||||
cipherType: model.C1C3C2,
|
||||
|
||||
sdk: sdk.NewBaseSdk(),
|
||||
}
|
||||
|
||||
sm2P256 := utils.NewP256Sm2()
|
||||
cmb.sm2P256 = &sm2P256
|
||||
|
||||
if err := cmb.setHexPrivateKey(privateKey); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := cmb.setHexPublicKey(sopPublicKey); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return cmb, nil
|
||||
}
|
||||
|
||||
func (s *Cmb) setHexPublicKey(hexStr string) error {
|
||||
|
||||
d, err := hex.DecodeString(hexStr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("publicKey is not hex string: %s", err.Error())
|
||||
}
|
||||
|
||||
s.publicKey, err = utils.HexToPublicKey(s.sm2P256, d)
|
||||
if err != nil {
|
||||
return fmt.Errorf("parse publicKey err: %+v", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Cmb) setHexPrivateKey(hexStr string) error {
|
||||
|
||||
d, err := hex.DecodeString(hexStr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("privateKey is not hex string: %s", err.Error())
|
||||
}
|
||||
|
||||
s.privateKey, err = utils.HexToPrivateKey(s.sm2P256, d)
|
||||
if err != nil {
|
||||
return fmt.Errorf("parse privateKey err: %+v", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Cmb) Encrypt(input []byte) (string, error) {
|
||||
|
||||
if input == nil {
|
||||
return "", fmt.Errorf("加密元数据 is empty")
|
||||
}
|
||||
|
||||
sm4Key := utils.GenerateSM4Key()
|
||||
iv := utils.GetSM4IV()
|
||||
|
||||
encryptedBody, err := sm4.CBCEncrypt(sm4Key, iv, utils.Padding(input, 1))
|
||||
|
||||
keyAndIv := utils.AssemblingByteArray(sm4Key, iv)
|
||||
|
||||
data := []byte(base64.StdEncoding.EncodeToString(keyAndIv))
|
||||
|
||||
kvTmp, err := s.encrypt(data)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%s|%s", base64.StdEncoding.EncodeToString([]byte(kvTmp)), base64.StdEncoding.EncodeToString(encryptedBody)), nil
|
||||
}
|
||||
|
||||
func (s *Cmb) encrypt(data []byte) ([]byte, error) {
|
||||
|
||||
c2 := make([]byte, len(data))
|
||||
copy(c2, data)
|
||||
|
||||
var c1 []byte
|
||||
var kx, ky *big.Int
|
||||
for {
|
||||
k, err := rand.Int(rand.Reader, s.publicKey.Params().N)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("rand error: %v", err)
|
||||
}
|
||||
c1x, c1y := s.publicKey.Curve.ScalarBaseMult(k.Bytes())
|
||||
c1 = elliptic.Marshal(s.publicKey.Curve, c1x, c1y)
|
||||
kx, ky = s.publicKey.Curve.ScalarMult(s.publicKey.X, s.publicKey.Y, k.Bytes())
|
||||
|
||||
err = s.sdk.Kdf(s.publicKey, kx, ky, c2)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("kdf error: %v", err)
|
||||
}
|
||||
if s.encrypted(c2, data) {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
c3 := s.sdk.CalculateHash(kx, data, ky)
|
||||
|
||||
c1Len := len(c1)
|
||||
c2Len := len(c2)
|
||||
c3Len := len(c3)
|
||||
|
||||
toData := make([]byte, c1Len+c2Len+c3Len)
|
||||
|
||||
if s.cipherType == model.C1C2C3 {
|
||||
copy(toData[:c1Len], c1)
|
||||
copy(toData[c1Len:c1Len+c2Len], c2)
|
||||
copy(toData[c1Len+c2Len:], c3)
|
||||
} else if s.cipherType == model.C1C3C2 {
|
||||
copy(toData[:c1Len], c1)
|
||||
copy(toData[c1Len:c1Len+c3Len], c3)
|
||||
copy(toData[c1Len+c3Len:], c2)
|
||||
} else {
|
||||
return nil, fmt.Errorf("cipher type not support")
|
||||
}
|
||||
|
||||
return toData, nil
|
||||
}
|
||||
|
||||
func (s *Cmb) encrypted(encData []byte, in []byte) bool {
|
||||
encDataLen := len(encData)
|
||||
|
||||
for i := 0; i != encDataLen; i++ {
|
||||
if encData[i] != in[i] {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (s *Cmb) Decrypt(input string) (string, error) {
|
||||
|
||||
tmpDataArr := strings.Split(input, "|")
|
||||
if len(tmpDataArr) != 2 {
|
||||
return "", fmt.Errorf("数据格式错误")
|
||||
}
|
||||
|
||||
keyAndIvStr := tmpDataArr[0]
|
||||
encryptedBody := tmpDataArr[1]
|
||||
|
||||
data, err := base64.StdEncoding.DecodeString(keyAndIvStr)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("data is not base64 string: %s", err.Error())
|
||||
}
|
||||
|
||||
kvBase64Tmp, err := s.decrypt(data)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
kvTmp, err := base64.StdEncoding.DecodeString(kvBase64Tmp)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
if len(kvTmp) != 33 {
|
||||
return "", fmt.Errorf("iv长度不等于33")
|
||||
}
|
||||
|
||||
plainKey := kvTmp[0:16]
|
||||
plainIv := kvTmp[17:33]
|
||||
|
||||
data2, err := base64.StdEncoding.DecodeString(encryptedBody)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
plainText, err := sm4.CBCDecrypt(plainKey, plainIv, data2)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
return string(utils.Padding(plainText, 0)), nil
|
||||
}
|
||||
|
||||
func (s *Cmb) decrypt(data []byte) (string, error) {
|
||||
|
||||
c1Len := 65
|
||||
C1Byte := make([]byte, c1Len)
|
||||
copy(C1Byte, data[:c1Len])
|
||||
|
||||
x, y := elliptic.Unmarshal(s.privateKey.Curve, C1Byte)
|
||||
dBC1X, dBC1Y := s.privateKey.Curve.ScalarMult(x, y, s.privateKey.D.Bytes())
|
||||
|
||||
c2Len := len(data) - c1Len - s.c3Len
|
||||
c2 := make([]byte, c2Len)
|
||||
c3 := make([]byte, s.c3Len)
|
||||
|
||||
if s.cipherType == model.C1C2C3 {
|
||||
copy(c2, data[c1Len:c1Len+c2Len])
|
||||
copy(c3, data[c1Len+c2Len:])
|
||||
} else if s.cipherType == model.C1C3C2 {
|
||||
copy(c3, data[c1Len:c1Len+s.c3Len])
|
||||
copy(c2, data[c1Len+s.c3Len:])
|
||||
} else {
|
||||
return "", fmt.Errorf("cipher type not support")
|
||||
}
|
||||
|
||||
if err := s.sdk.Kdf(s.privateKey.Curve, dBC1X, dBC1Y, c2); err != nil {
|
||||
return "", fmt.Errorf("kdf error: %v", err)
|
||||
}
|
||||
|
||||
u := s.sdk.CalculateHash(dBC1X, c2, dBC1Y)
|
||||
if bytes.Compare(u, c3) == 0 {
|
||||
return string(c2), nil
|
||||
}
|
||||
|
||||
return "", fmt.Errorf("decrypt error")
|
||||
}
|
||||
|
||||
func (s *Cmb) Sign(input []byte) (string, error) {
|
||||
|
||||
signData, err := s.sign(input)
|
||||
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
return base64.StdEncoding.EncodeToString(signData), nil
|
||||
}
|
||||
|
||||
func (s *Cmb) sign(data []byte) ([]byte, error) {
|
||||
|
||||
z := s.sdk.GetZ(s.privateKey.PublicKey.X, s.privateKey.PublicKey.Y, s.uid)
|
||||
e := s.sdk.GetE(z, data)
|
||||
|
||||
c := s.privateKey.PublicKey.Curve
|
||||
N := c.Params().N
|
||||
|
||||
if N.Sign() == 0 {
|
||||
return nil, fmt.Errorf("invalid curve order")
|
||||
}
|
||||
|
||||
var k, r, sb *big.Int
|
||||
var err error
|
||||
for {
|
||||
for {
|
||||
k, err = s.randFieldElement(c, rand.Reader)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("randFieldElement: %+v", err)
|
||||
}
|
||||
r, _ = s.privateKey.Curve.ScalarBaseMult(k.Bytes())
|
||||
r.Add(r, e)
|
||||
r.Mod(r, N)
|
||||
if r.Sign() != 0 {
|
||||
if t := new(big.Int).Add(r, k); t.Cmp(N) != 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
rD := new(big.Int).Mul(s.privateKey.D, r)
|
||||
sb = new(big.Int).Sub(k, rD)
|
||||
d1 := new(big.Int).Add(s.privateKey.D, model.One)
|
||||
d1Inv := new(big.Int).ModInverse(d1, N)
|
||||
sb.Mul(sb, d1Inv)
|
||||
sb.Mod(sb, N)
|
||||
if sb.Sign() != 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
signature := model.Signature{R: r, S: sb}
|
||||
|
||||
si, err := asn1.Marshal(signature)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("asn1.Marshal: %+v", err)
|
||||
}
|
||||
|
||||
return si, nil
|
||||
}
|
||||
|
||||
func (s *Cmb) randFieldElement(c elliptic.Curve, random io.Reader) (k *big.Int, err error) {
|
||||
params := c.Params()
|
||||
b := make([]byte, params.BitSize/8+8)
|
||||
_, err = io.ReadFull(random, b)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
k = new(big.Int).SetBytes(b)
|
||||
n := new(big.Int).Sub(params.N, model.One)
|
||||
k.Mod(k, n)
|
||||
k.Add(k, model.One)
|
||||
return
|
||||
}
|
||||
|
||||
func (s *Cmb) Verify(input, sign string) (bool, error) {
|
||||
|
||||
signBytes, err := base64.StdEncoding.DecodeString(sign)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("signature is not base64 string: %s", err.Error())
|
||||
}
|
||||
|
||||
signature := model.Signature{}
|
||||
_, err = asn1.Unmarshal(signBytes, &signature)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("signature is not asn1: %s", err.Error())
|
||||
}
|
||||
|
||||
ok := s.verify([]byte(input), signature)
|
||||
|
||||
if !ok {
|
||||
return false, nil
|
||||
}
|
||||
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (s *Cmb) verifyBool(data []byte) bool {
|
||||
if bytes.Equal(data, model.VerifyTrue) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (s *Cmb) verify(data []byte, signature model.Signature) bool {
|
||||
|
||||
c := s.publicKey.Curve
|
||||
N := c.Params().N
|
||||
|
||||
if signature.R.Cmp(model.One) < 0 || signature.S.Cmp(model.One) < 0 {
|
||||
return s.verifyBool(model.VerifyFalse)
|
||||
}
|
||||
|
||||
if signature.R.Cmp(N) >= 0 || signature.S.Cmp(N) >= 0 {
|
||||
return s.verifyBool(model.VerifyFalse)
|
||||
}
|
||||
|
||||
z := s.sdk.GetZ(s.publicKey.X, s.publicKey.Y, s.uid)
|
||||
e := s.sdk.GetE(z, data)
|
||||
t := new(big.Int).Add(signature.R, signature.S)
|
||||
t.Mod(t, N)
|
||||
|
||||
if t.Sign() == 0 {
|
||||
return s.verifyBool(model.VerifyFalse)
|
||||
}
|
||||
|
||||
var x *big.Int
|
||||
x1, y1 := c.ScalarBaseMult(signature.S.Bytes())
|
||||
x2, y2 := c.ScalarMult(s.publicKey.X, s.publicKey.Y, t.Bytes())
|
||||
x, _ = c.Add(x1, y1, x2, y2)
|
||||
|
||||
x.Add(x, e)
|
||||
x.Mod(x, N)
|
||||
if x.Cmp(signature.R) == 0 {
|
||||
return s.verifyBool(model.VerifyTrue)
|
||||
}
|
||||
|
||||
return s.verifyBool(model.VerifyFalse)
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
package cmbv2
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCmb_EncryptDecrypt(t *testing.T) {
|
||||
priKey := "8d39ff3d2559258c163f4510f082727f51531e1953ab203d5ab1ea4a6d94fd73"
|
||||
pukKey := "04d827a7dbaaa358ce45b8c7794a7f54819f5c175005a702370e47f135ef6f5f9732758b1474f218419fe9e87f90c28c3b05f08254c651db27df35fae67b77b2e4"
|
||||
|
||||
n, err := NewCmb(priKey, pukKey)
|
||||
if err != nil {
|
||||
t.Errorf("NewCmb() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
content := `{"name":"zhangxx","phoneNo":"137xxxxxxxx"}`
|
||||
|
||||
got, err := n.Encrypt([]byte(content))
|
||||
if err != nil {
|
||||
t.Errorf("Encrypt() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
t.Log(got)
|
||||
|
||||
got2, err := n.Decrypt(got)
|
||||
if err != nil {
|
||||
t.Errorf("Decrypt() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
t.Log(got2)
|
||||
}
|
||||
|
||||
func TestCmb_SignVerify(t *testing.T) {
|
||||
priKey := "8d39ff3d2559258c163f4510f082727f51531e1953ab203d5ab1ea4a6d94fd73"
|
||||
pukKey := "04d827a7dbaaa358ce45b8c7794a7f54819f5c175005a702370e47f135ef6f5f9732758b1474f218419fe9e87f90c28c3b05f08254c651db27df35fae67b77b2e4"
|
||||
|
||||
n, err := NewCmb(priKey, pukKey)
|
||||
if err != nil {
|
||||
t.Errorf("NewCmb() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
content := `{"name":"zhangxx","phoneNo":"137xxxxxxxx"}`
|
||||
|
||||
got, err := n.Sign([]byte(content))
|
||||
if err != nil {
|
||||
t.Errorf("Sign() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
t.Log(got)
|
||||
|
||||
got2, err := n.Verify(content, got)
|
||||
if err != nil {
|
||||
t.Errorf("Verify() error = %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
t.Log(got2)
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,329 @@
|
|||
package utils
|
||||
|
||||
import (
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"crypto/elliptic"
|
||||
"crypto/hmac"
|
||||
"crypto/md5"
|
||||
"crypto/rand"
|
||||
"crypto/sha1"
|
||||
"crypto/sha256"
|
||||
"crypto/sha512"
|
||||
"crypto/x509/pkix"
|
||||
"encoding/asn1"
|
||||
"fmt"
|
||||
"hash"
|
||||
"math/big"
|
||||
"reflect"
|
||||
"voucher/internal/pkg/cmb/sm2/model"
|
||||
)
|
||||
|
||||
/*
|
||||
* reference to RFC5959 and RFC2898
|
||||
*/
|
||||
|
||||
var (
|
||||
oidPBES2 = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 13} // id-PBES2(PBES2)
|
||||
oidPBKDF2 = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 12} // id-PBKDF2
|
||||
|
||||
oidAES128CBC = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 2}
|
||||
oidAES256CBC = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 42}
|
||||
|
||||
oidKEYMD5 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 5}
|
||||
oidKEYSHA1 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 7}
|
||||
oidKEYSHA256 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 9}
|
||||
oidKEYSHA512 = asn1.ObjectIdentifier{1, 2, 840, 113549, 2, 11}
|
||||
|
||||
oidSM2 = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1}
|
||||
)
|
||||
|
||||
type Sm2PrivateKey struct {
|
||||
Version int
|
||||
PrivateKey []byte
|
||||
NamedCurveOID asn1.ObjectIdentifier `asn1:"optional,explicit,tag:0"`
|
||||
PublicKey asn1.BitString `asn1:"optional,explicit,tag:1"`
|
||||
}
|
||||
|
||||
type pkcs8 struct {
|
||||
Version int
|
||||
Algo pkix.AlgorithmIdentifier
|
||||
PrivateKey []byte
|
||||
}
|
||||
|
||||
// EncryptedPrivateKeyInfo reference to https://www.rfc-editor.org/rfc/rfc5958.txt
|
||||
type EncryptedPrivateKeyInfo struct {
|
||||
EncryptionAlgorithm Pbes2Algorithms
|
||||
EncryptedData []byte
|
||||
}
|
||||
|
||||
// Pbes2Algorithms reference to https://www.ietf.org/rfc/rfc2898.txt
|
||||
type Pbes2Algorithms struct {
|
||||
IdPBES2 asn1.ObjectIdentifier
|
||||
Pbes2Params Pbes2Params
|
||||
}
|
||||
|
||||
// Pbes2Params reference to https://www.ietf.org/rfc/rfc2898.txt
|
||||
type Pbes2Params struct {
|
||||
KeyDerivationFunc Pbes2KDfs // PBES2-KDFs
|
||||
EncryptionScheme Pbes2Encs // PBES2-Encs
|
||||
}
|
||||
|
||||
// Pbes2KDfs reference to https://www.ietf.org/rfc/rfc2898.txt
|
||||
type Pbes2KDfs struct {
|
||||
IdPBKDF2 asn1.ObjectIdentifier
|
||||
Pkdf2Params Pkdf2Params
|
||||
}
|
||||
type Pbes2Encs struct {
|
||||
EncryAlgo asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}
|
||||
|
||||
// Pkdf2Params reference to https://www.ietf.org/rfc/rfc2898.txt
|
||||
type Pkdf2Params struct {
|
||||
Salt []byte
|
||||
IterationCount int
|
||||
Prf pkix.AlgorithmIdentifier
|
||||
}
|
||||
|
||||
func ParsePrivateKey(bytes []byte, pwd []byte) (*model.PrivateKey, error) {
|
||||
var priKey Sm2PrivateKey
|
||||
var err error
|
||||
if pwd == nil {
|
||||
priKey, err = ParsePKCS8UnEncryptedPrivateKey(bytes)
|
||||
} else {
|
||||
priKey, err = ParsePKCS8EncryptedPrivateKey(bytes, pwd)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse private key err: %s", err.Error())
|
||||
}
|
||||
curve := NewP256Sm2()
|
||||
k := new(big.Int).SetBytes(priKey.PrivateKey)
|
||||
curveOrder := curve.Params().N
|
||||
if k.Cmp(curveOrder) >= 0 {
|
||||
return nil, fmt.Errorf("invalid elliptic curve private key value")
|
||||
}
|
||||
privateKey := make([]byte, (curveOrder.BitLen()+7)/8)
|
||||
for len(priKey.PrivateKey) > len(privateKey) {
|
||||
if priKey.PrivateKey[0] != 0 {
|
||||
return nil, fmt.Errorf("invalid private key")
|
||||
}
|
||||
priKey.PrivateKey = priKey.PrivateKey[1:]
|
||||
}
|
||||
copy(privateKey[len(privateKey)-len(priKey.PrivateKey):], priKey.PrivateKey)
|
||||
x, y := curve.ScalarBaseMult(privateKey)
|
||||
return &model.PrivateKey{
|
||||
PublicKey: &model.PublicKey{
|
||||
Curve: curve,
|
||||
X: x,
|
||||
Y: y,
|
||||
},
|
||||
D: k,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func ParsePKCS8UnEncryptedPrivateKey(bytes []byte) (Sm2PrivateKey, error) {
|
||||
var pk pkcs8
|
||||
var priKey Sm2PrivateKey
|
||||
|
||||
if _, err := asn1.Unmarshal(bytes, &pk); err != nil {
|
||||
return priKey, err
|
||||
}
|
||||
if !reflect.DeepEqual(pk.Algo.Algorithm, oidSM2) {
|
||||
return priKey, fmt.Errorf("not sm2 elliptic curve")
|
||||
}
|
||||
|
||||
if _, err := asn1.Unmarshal(pk.PrivateKey, &priKey); err != nil {
|
||||
return priKey, fmt.Errorf("privateKey is not sm2 private key: %s", err.Error())
|
||||
}
|
||||
return priKey, nil
|
||||
}
|
||||
|
||||
func ParsePKCS8EncryptedPrivateKey(bytes, pwd []byte) (Sm2PrivateKey, error) {
|
||||
var keyInfo EncryptedPrivateKeyInfo
|
||||
var priKey Sm2PrivateKey
|
||||
_, err := asn1.Unmarshal(bytes, &keyInfo)
|
||||
if err != nil {
|
||||
return priKey, fmt.Errorf("privateKey is not sm2 encrypted private key: %s", err.Error())
|
||||
}
|
||||
if !reflect.DeepEqual(keyInfo.EncryptionAlgorithm.IdPBES2, oidPBES2) {
|
||||
return priKey, fmt.Errorf("x509: only support PBES2")
|
||||
}
|
||||
encryptionScheme := keyInfo.EncryptionAlgorithm.Pbes2Params.EncryptionScheme
|
||||
keyDerivationFunc := keyInfo.EncryptionAlgorithm.Pbes2Params.KeyDerivationFunc
|
||||
if !reflect.DeepEqual(keyDerivationFunc.IdPBKDF2, oidPBKDF2) {
|
||||
return priKey, fmt.Errorf("x509: only support PBKDF2")
|
||||
}
|
||||
pkdf2Params := keyDerivationFunc.Pkdf2Params
|
||||
if !reflect.DeepEqual(encryptionScheme.EncryAlgo, oidAES128CBC) &&
|
||||
!reflect.DeepEqual(encryptionScheme.EncryAlgo, oidAES256CBC) {
|
||||
return priKey, fmt.Errorf("x509: only support AES")
|
||||
}
|
||||
iv := encryptionScheme.IV
|
||||
salt := pkdf2Params.Salt
|
||||
iter := pkdf2Params.IterationCount
|
||||
encryptedKey := keyInfo.EncryptedData
|
||||
var key []byte
|
||||
switch {
|
||||
case pkdf2Params.Prf.Algorithm.Equal(oidKEYMD5):
|
||||
key = pbkdf(pwd, salt, iter, 32, md5.New)
|
||||
break
|
||||
case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA1):
|
||||
key = pbkdf(pwd, salt, iter, 32, sha1.New)
|
||||
break
|
||||
case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA256):
|
||||
key = pbkdf(pwd, salt, iter, 32, sha256.New)
|
||||
break
|
||||
case pkdf2Params.Prf.Algorithm.Equal(oidKEYSHA512):
|
||||
key = pbkdf(pwd, salt, iter, 32, sha512.New)
|
||||
break
|
||||
default:
|
||||
return priKey, fmt.Errorf("x509: unknown hash algorithm")
|
||||
}
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return priKey, err
|
||||
}
|
||||
mode := cipher.NewCBCDecrypter(block, iv)
|
||||
mode.CryptBlocks(encryptedKey, encryptedKey)
|
||||
return ParsePKCS8UnEncryptedPrivateKey(encryptedKey)
|
||||
}
|
||||
|
||||
// copy from crypto/pbkdf2.go
|
||||
func pbkdf(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte {
|
||||
prf := hmac.New(h, password)
|
||||
hashLen := prf.Size()
|
||||
numBlocks := (keyLen + hashLen - 1) / hashLen
|
||||
|
||||
var buf [4]byte
|
||||
dk := make([]byte, 0, numBlocks*hashLen)
|
||||
U := make([]byte, hashLen)
|
||||
for block := 1; block <= numBlocks; block++ {
|
||||
// N.B.: || means concatenation, ^ means XOR
|
||||
// for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
|
||||
// U_1 = PRF(password, salt || uint(i))
|
||||
prf.Reset()
|
||||
prf.Write(salt)
|
||||
buf[0] = byte(block >> 24)
|
||||
buf[1] = byte(block >> 16)
|
||||
buf[2] = byte(block >> 8)
|
||||
buf[3] = byte(block)
|
||||
prf.Write(buf[:4])
|
||||
dk = prf.Sum(dk)
|
||||
T := dk[len(dk)-hashLen:]
|
||||
copy(U, T)
|
||||
|
||||
// U_n = PRF(password, U_(n-1))
|
||||
for n := 2; n <= iter; n++ {
|
||||
prf.Reset()
|
||||
prf.Write(U)
|
||||
U = U[:0]
|
||||
U = prf.Sum(U)
|
||||
for x := range U {
|
||||
T[x] ^= U[x]
|
||||
}
|
||||
}
|
||||
}
|
||||
return dk[:keyLen]
|
||||
}
|
||||
|
||||
func MarshalSm2PrivateKey(key *model.PrivateKey, pwd []byte) ([]byte, error) {
|
||||
if pwd == nil {
|
||||
return MarshalSm2UnEncryptedPrivateKey(key)
|
||||
}
|
||||
return MarshalSm2EncryptedPrivateKey(key, pwd)
|
||||
}
|
||||
|
||||
func MarshalSm2EncryptedPrivateKey(priKey *model.PrivateKey, pwd []byte) ([]byte, error) {
|
||||
der, err := MarshalSm2UnEncryptedPrivateKey(priKey)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
iter := 2048
|
||||
salt := make([]byte, 8)
|
||||
iv := make([]byte, 16)
|
||||
rand.Reader.Read(salt)
|
||||
rand.Reader.Read(iv)
|
||||
key := pbkdf(pwd, salt, iter, 32, sha1.New) // 默认是SHA1
|
||||
padding := aes.BlockSize - len(der)%aes.BlockSize
|
||||
if padding > 0 {
|
||||
n := len(der)
|
||||
der = append(der, make([]byte, padding)...)
|
||||
for i := 0; i < padding; i++ {
|
||||
der[n+i] = byte(padding)
|
||||
}
|
||||
}
|
||||
encryptedKey := make([]byte, len(der))
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
mode := cipher.NewCBCEncrypter(block, iv)
|
||||
mode.CryptBlocks(encryptedKey, der)
|
||||
var algorithmIdentifier pkix.AlgorithmIdentifier
|
||||
algorithmIdentifier.Algorithm = oidKEYSHA1
|
||||
algorithmIdentifier.Parameters.Tag = 5
|
||||
algorithmIdentifier.Parameters.IsCompound = false
|
||||
algorithmIdentifier.Parameters.FullBytes = []byte{5, 0}
|
||||
keyDerivationFunc := Pbes2KDfs{
|
||||
oidPBKDF2,
|
||||
Pkdf2Params{
|
||||
salt,
|
||||
iter,
|
||||
algorithmIdentifier,
|
||||
},
|
||||
}
|
||||
encryptionScheme := Pbes2Encs{
|
||||
oidAES256CBC,
|
||||
iv,
|
||||
}
|
||||
pbes2Algorithms := Pbes2Algorithms{
|
||||
oidPBES2,
|
||||
Pbes2Params{
|
||||
keyDerivationFunc,
|
||||
encryptionScheme,
|
||||
},
|
||||
}
|
||||
encryptedPkey := EncryptedPrivateKeyInfo{
|
||||
pbes2Algorithms,
|
||||
encryptedKey,
|
||||
}
|
||||
return asn1.Marshal(encryptedPkey)
|
||||
}
|
||||
|
||||
func MarshalSm2UnEncryptedPrivateKey(key *model.PrivateKey) ([]byte, error) {
|
||||
var r pkcs8
|
||||
var pri Sm2PrivateKey
|
||||
var algo pkix.AlgorithmIdentifier
|
||||
|
||||
algo.Algorithm = oidSM2
|
||||
algo.Parameters.Class = 0
|
||||
algo.Parameters.Tag = 6
|
||||
algo.Parameters.IsCompound = false
|
||||
algo.Parameters.FullBytes = []byte{6, 8, 42, 129, 28, 207, 85, 1, 130, 45} // asn1.Marshal(asn1.ObjectIdentifier{1, 2, 156, 10197, 1, 301})
|
||||
pri.Version = 1
|
||||
pri.NamedCurveOID = oidNamedCurveP256SM2
|
||||
pri.PublicKey = asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)}
|
||||
pri.PrivateKey = key.D.Bytes()
|
||||
r.Version = 0
|
||||
r.Algo = algo
|
||||
r.PrivateKey, _ = asn1.Marshal(pri)
|
||||
return asn1.Marshal(r)
|
||||
}
|
||||
|
||||
func MarshalSm2PublicKey(key *model.PublicKey) ([]byte, error) {
|
||||
var r PKIXPublicKey
|
||||
var algo pkix.AlgorithmIdentifier
|
||||
|
||||
if key.Curve.Params() != NewP256Sm2().Params() {
|
||||
return nil, fmt.Errorf("x509: unsupported elliptic curve")
|
||||
}
|
||||
algo.Algorithm = oidSM2
|
||||
algo.Parameters.Class = 0
|
||||
algo.Parameters.Tag = 6
|
||||
algo.Parameters.IsCompound = false
|
||||
algo.Parameters.FullBytes = []byte{6, 8, 42, 129, 28, 207, 85, 1, 130, 45} // asn1.Marshal(asn1.ObjectIdentifier{1, 2, 156, 10197, 1, 301})
|
||||
r.Algo = algo
|
||||
r.BitString = asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)}
|
||||
return asn1.Marshal(r)
|
||||
}
|
||||
|
|
@ -0,0 +1,209 @@
|
|||
package utils
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"math/big"
|
||||
"strings"
|
||||
"voucher/internal/pkg/cmbv2/model"
|
||||
"voucher/internal/pkg/helper"
|
||||
)
|
||||
|
||||
func GenerateSM4Key() []byte {
|
||||
str := "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"
|
||||
buffer := make([]byte, 16)
|
||||
for i := 0; i < 16; i++ {
|
||||
nextInt, _ := rand.Int(rand.Reader, big.NewInt(int64(len(str))))
|
||||
buffer[i] = str[nextInt.Int64()]
|
||||
}
|
||||
return buffer
|
||||
}
|
||||
|
||||
// GetSM4IV 获取SM4的IV
|
||||
func GetSM4IV() []byte {
|
||||
return RandomBytes(16)
|
||||
}
|
||||
|
||||
func RandomBytes(length int) []byte {
|
||||
str := "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"
|
||||
buffer := make([]byte, length)
|
||||
for i := 0; i < 16; i++ {
|
||||
nextInt, _ := rand.Int(rand.Reader, big.NewInt(int64(len(str))))
|
||||
buffer[i] = str[nextInt.Int64()]
|
||||
}
|
||||
return buffer
|
||||
}
|
||||
|
||||
func Padding(input []byte, mode int) []byte {
|
||||
if input == nil {
|
||||
return nil
|
||||
} else {
|
||||
var ret []byte
|
||||
if mode == 1 {
|
||||
p := 16 - len(input)%16
|
||||
ret = make([]byte, len(input)+p)
|
||||
copy(ret, input)
|
||||
|
||||
for i := 0; i < p; i++ {
|
||||
ret[len(input)+i] = byte(p)
|
||||
}
|
||||
} else {
|
||||
p := input[len(input)-1]
|
||||
ret = make([]byte, len(input)-int(p))
|
||||
copy(ret, input[:len(input)-int(p)])
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
}
|
||||
|
||||
func AssemblingByteArray(key, iv []byte) []byte {
|
||||
os := make([]byte, 0)
|
||||
os = append(os, key...)
|
||||
os = append(os, []byte("|")...)
|
||||
os = append(os, iv...)
|
||||
return os
|
||||
}
|
||||
|
||||
func SortStructStr(req interface{}) string {
|
||||
kvRows := helper.SortStructFieldsByKey(req)
|
||||
|
||||
var strToBeSigned strings.Builder
|
||||
for _, kv := range kvRows {
|
||||
if kv.Key == "sign" {
|
||||
continue
|
||||
}
|
||||
if kv.Value == "" {
|
||||
continue
|
||||
}
|
||||
strToBeSigned.WriteString(fmt.Sprintf("%s=%s&", kv.Key, kv.Value))
|
||||
}
|
||||
|
||||
return strings.TrimRight(strToBeSigned.String(), "&")
|
||||
}
|
||||
|
||||
func BigIntToByte(n *big.Int) []byte {
|
||||
byteArray := n.Bytes()
|
||||
|
||||
// If the bytes is not a multiple of 32, pad with zero bytes.
|
||||
byteArrLen := len(byteArray)
|
||||
KeyBytes := 32
|
||||
if byteArrLen == KeyBytes {
|
||||
return byteArray
|
||||
}
|
||||
byteArray = append(make([]byte, KeyBytes-byteArrLen), byteArray...)
|
||||
|
||||
// If the most significant byte's most significant bit is set,
|
||||
// prepend a 0 byte to the slice to avoid being interpreted as a negative number.
|
||||
if (byteArray[0] & 0x80) != 0 {
|
||||
byteArray = append([]byte{0}, byteArray...)
|
||||
}
|
||||
return byteArray
|
||||
}
|
||||
|
||||
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(params *Sm2P256Curve, 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(curve *Sm2P256Curve, 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 = curve
|
||||
|
||||
pub.X = new(big.Int).SetBytes(d[:32])
|
||||
pub.Y = new(big.Int).SetBytes(d[32:])
|
||||
|
||||
return pub, 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
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
package utils
|
||||
|
||||
import (
|
||||
"crypto/elliptic"
|
||||
"crypto/x509/pkix"
|
||||
"encoding/asn1"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"voucher/internal/pkg/cmb/sm2/model"
|
||||
)
|
||||
|
||||
var (
|
||||
oidNamedCurveP256SM2 = asn1.ObjectIdentifier{1, 2, 156, 10197, 1, 301} // I get the SM2 ID through parsing the pem file generated by gmssl
|
||||
)
|
||||
|
||||
// PKIXPublicKey reflects a PKIX public key structure. See SubjectPublicKeyInfo
|
||||
// in RFC 3280.
|
||||
type PKIXPublicKey struct {
|
||||
Algo pkix.AlgorithmIdentifier
|
||||
BitString asn1.BitString
|
||||
}
|
||||
|
||||
func ParsePublicKey(bytes []byte) (*model.PublicKey, error) {
|
||||
var pk PKIXPublicKey
|
||||
if _, err := asn1.Unmarshal(bytes, &pk); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !reflect.DeepEqual(pk.Algo.Algorithm, oidSM2) {
|
||||
return nil, fmt.Errorf("not sm2 elliptic curve")
|
||||
}
|
||||
curve := NewP256Sm2()
|
||||
x, y := elliptic.Unmarshal(curve, pk.BitString.Bytes)
|
||||
return &model.PublicKey{
|
||||
Curve: curve,
|
||||
X: x,
|
||||
Y: y,
|
||||
}, nil
|
||||
}
|
||||
Loading…
Reference in New Issue