XinYeYouKu/app/third/dfpOpenSdk/util/signature.go

package util

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/asn1"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/tjfoc/gmsm/sm2"
	"github.com/tjfoc/gmsm/x509"
	"math/big"
	"net/url"
	"qteam/app/third/dfpOpenSdk/config"
	"strings"
)

// SignatureByRSA RSA签名
func SignatureByRSA(content string, privateKey string) string {
	decodeString, err := base64.StdEncoding.DecodeString(privateKey)
	if err != nil {
		return ""
	}
	hash := sha256.New()
	hash.Write([]byte(content))
	//Step3：获得明文的散列值
	hashText := hash.Sum(nil)

	private, err := x509.ParsePKCS1PrivateKey(decodeString)
	sign, err := rsa.SignPKCS1v15(
		rand.Reader,
		private,
		crypto.SHA256,
		hashText,
	)

	return base64.StdEncoding.EncodeToString(sign)
}

type sm2Signature struct {
	R, S *big.Int
}

// SignatureBySM2 SM2签名
func SignatureBySM2(content string, privateKey string) (string, error) {
	decodeString, _ := base64.StdEncoding.DecodeString(privateKey)
	pri, err := FormatPri(decodeString)
	if err != nil {
		return "", err
	}

	sign, _ := pri.Sign(rand.Reader, []byte(content), nil)
	signature := sm2Signature{}
	_, err = asn1.Unmarshal(sign, &signature)
	if err != nil {
		return "", err
	}
	rbytes := signature.R.Bytes()
	sbytes := signature.S.Bytes()
	resultbytes := append(rbytes, sbytes...)

	return base64.StdEncoding.EncodeToString(resultbytes), nil
}

func VerifyBySM2(contentBytes []byte, sign string, publicKey string) (bool, error) {
	pubKey := FromPublicKey(publicKey)
	//pri, err := FormatPri(decodeString)
	//if err != nil {
	//	log.Fatal(err)
	//	return false, err
	//}
	bytes, _ := base64.StdEncoding.DecodeString(sign)
	verify := pubKey.Verify(contentBytes, bytes)
	//verify := pri.Verify(contentBytes, bytes)
	return verify, nil
}

// EncryptBySM2PublicKey sm2公钥加密, 结果为base64格式
func EncryptBySM2PublicKey(encodedPublicKey string, contentBytes []byte) (string, error) {
	decodeString, err2 := base64.StdEncoding.DecodeString(encodedPublicKey)
	if err2 != nil {
		return "", nil
	}
	public, err := x509.ReadPublicKeyFromHex(hex.EncodeToString(decodeString))
	if err != nil {
		return "", err
	}
	//
	asn1Encrypt, err := public.EncryptAsn1(contentBytes, rand.Reader)
	if err != nil {
		return "", err
	}
	unmarshal, err := sm2.CipherUnmarshal(asn1Encrypt)
	return base64.StdEncoding.EncodeToString(unmarshal), nil
}

// DecryptBySM2PrivateKey sm2私钥解密
func DecryptBySM2PrivateKey(encodedPrivateKey string, contentBytes []byte) ([]byte, error) {
	decodeString, err := base64.StdEncoding.DecodeString(encodedPrivateKey)
	if err != nil {
		return nil, err
	}
	privateKey, err := x509.ReadPrivateKeyFromHex(hex.EncodeToString(decodeString))
	if err != nil {
		return nil, err
	}

	// 解析密文
	base64Content, err := base64.StdEncoding.DecodeString(string(contentBytes))
	if err != nil {
		return nil, err
	}
	asn1Encrypt, err := sm2.CipherMarshal(base64Content)
	if err != nil {
		return nil, err
	}

	plaintext, err := privateKey.DecryptAsn1(asn1Encrypt)

	if err != nil {
		return nil, err
	}
	return plaintext, nil
}

// FormatPri 从私钥base64格式生成对应私钥格式
func FormatPri(priByte []byte) (*sm2.PrivateKey, error) {
	// 椭圆曲线
	c := sm2.P256Sm2()
	// k倍点
	k := new(big.Int).SetBytes(priByte)
	priv := new(sm2.PrivateKey)
	priv.PublicKey.Curve = c
	priv.D = k
	priv.PublicKey.X, priv.PublicKey.Y = c.ScalarBaseMult(k.Bytes())
	return priv, nil
}

func FromPublicKey(publicKey string) *sm2.PublicKey {
	decodeKey, _ := base64.StdEncoding.DecodeString(publicKey)

	hexPublic := hex.EncodeToString(decodeKey)
	pubKey, _ := x509.ReadPublicKeyFromHex(hexPublic)
	return pubKey
}

func SM2_GenerateKeyPair() (publicKey string, privateKey string, err error) {
	privKey, err := sm2.GenerateKey(nil) // 生成密钥对
	if err != nil {
		return
	}
	privateKey = x509.WritePrivateKeyToHex(privKey)
	publicKey = x509.WritePublicKeyToHex(&privKey.PublicKey)

	pr, _ := hex.DecodeString(privateKey)
	pb, _ := hex.DecodeString(publicKey)

	privateKey = base64.StdEncoding.EncodeToString(pr)
	publicKey = base64.StdEncoding.EncodeToString(pb)
	return
}

func SM4_GenerateKeyPair() string {
	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 base64.StdEncoding.EncodeToString(buffer)
	//return string(buffer)
}

func encryptBody(bodyParamString string, keyConfigure config.KeyConfigure, flag bool) {
	encryptBodyParamMap := make(map[string]string, 10)
	var encData string
	var encPassword string
	if keyConfigure.RespSignAlgorithm == "sm4" {
		pwd := SM4_GenerateKeyPair()
		encData, _ = Sm4Encrypt(bodyParamString, pwd)
		encPassword, _ = SignatureBySM2(bodyParamString, keyConfigure.PriKey)
	}
	encryptBodyParamMap["encData"] = encData
	encryptBodyParamMap["encPassword"] = encPassword
}

func EncryptBody(bodyParamString string, keyConfigure config.KeyConfigure, flag bool) (string, error) {
	encryptBodyParamMap := make(map[string]string, 10)
	var encData string
	var encPassword string
	var err error

	if keyConfigure.RespSignAlgorithm == "sm4" {
		// 生成SM4密钥
		pwd := SM4_GenerateKeyPair()
		pwd = "9A9A4QyNz/pc8kZZXzhXOQ=="
		// 使用SM4算法加密请求报文内容
		encData, err = SM4Encrypt(bodyParamString, pwd)
		if err != nil {
			return "", err
		}

		// 使用SM2公钥对SM4密钥进行加密
		//// 使用自己的密钥加解密
		//{
		//	pub, pri, _ := SM2_GenerateKeyPair()
		//	fmt.Println("pub=", pub)
		//	fmt.Println("pri=", pri)
		//	encPassword, err = EncryptBySM2PublicKey(pub, []byte(pwd))
		//	if err != nil {
		//		return "", err
		//	}
		//	//fmt.Println("pub=", keyConfigure.RespPubKey)
		//	//fmt.Println("encPassword=", encPassword)
		//	content, err := DecryptBySM2PrivateKey(pri, []byte(encPassword))
		//	if err != nil {
		//		return "", err
		//	}
		//	fmt.Println("加密内容content=", pwd)
		//	fmt.Println("解密内容content=", string(content))
		//}

		encPassword, err = EncryptBySM2PublicKey(keyConfigure.RespPubKey, []byte(pwd))
		if err != nil {
			return "", err
		}
	}

	encryptBodyParamMap["encData"] = encData
	encryptBodyParamMap["encPassword"] = encPassword
	// 根据flag的值决定返回JSON字符串还是拼接的字符串
	if flag {
		return JSONMarshal(encryptBodyParamMap)
	} else {
		return MapToString(encryptBodyParamMap), nil
	}
}

// form 形式
func EncryptBody2(bodyParamString string, keyConfigure config.KeyConfigure, flag bool) (formData url.Values, err error) {
	//encryptBodyParamMap := make(map[string]string, 10)
	var encData string
	var encPassword string
	formData = url.Values{}

	if keyConfigure.RespSignAlgorithm == "sm4" {
		// 生成SM4密钥
		pwd := SM4_GenerateKeyPair()
		pwd = "a0l5MEZwMFpVQ08zaUszWg=="
		// 使用SM4算法加密请求报文内容
		encData, err = Sm4Encrypt(bodyParamString, pwd)
		if err != nil {
			return
		}
		fmt.Println("bodyParamString=", bodyParamString)
		fmt.Println("pwd=", pwd)

		// 使用SM2公钥对SM4密钥进行加密
		//// 使用自己的密钥加解密
		//{
		//	pub, pri, _ := SM2_GenerateKeyPair()
		//	fmt.Println("pub=", pub)
		//	fmt.Println("pri=", pri)
		//	encPassword, err = EncryptBySM2PublicKey(pub, []byte(pwd))
		//	if err != nil {
		//		return "", err
		//	}
		//	//fmt.Println("pub=", keyConfigure.RespPubKey)
		//	//fmt.Println("encPassword=", encPassword)
		//	content, err := DecryptBySM2PrivateKey(pri, []byte(encPassword))
		//	if err != nil {
		//		return "", err
		//	}
		//	fmt.Println("加密内容content=", pwd)
		//	fmt.Println("解密内容content=", string(content))
		//}

		encPassword, err = EncryptBySM2PublicKey(keyConfigure.RespPubKey, []byte(pwd))
		if err != nil {
			return
		}
		fmt.Println("RespPubKey = ", keyConfigure.RespPubKey)
	}

	//encryptBodyParamMap["encData"] = encData
	//encryptBodyParamMap["encPassword"] = encPassword

	formData.Set("encData", encData)
	formData.Set("encPassword", encPassword)
	fmt.Println("encData=", encData)
	fmt.Println("encPassword=", encPassword)

	return
}

// JSONMarshal 将map转换为JSON字符串
func JSONMarshal(m map[string]string) (string, error) {
	b, err := json.Marshal(m)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

// MapToString 将map拼接成字符串（简单实现，不考虑编码问题）
func MapToString(m map[string]string) string {
	var parts []string
	for k, v := range m {
		parts = append(parts, fmt.Sprintf("%s=%s", k, v))
	}
	return strings.Join(parts, "&")
}

// EncryptBySM2PublicKey2 sm2公钥加密, 结果为base64格式
func EncryptBySM2PublicKey2(encodedPublicKey string, contentBytes []byte) (string, error) {
	decodeKey, err := base64.StdEncoding.DecodeString(encodedPublicKey)
	if err != nil {
		return "", err
	}
	hexPublic := hex.EncodeToString(decodeKey)
	pubKey, err := x509.ReadPublicKeyFromHex(hexPublic)
	if err != nil {
		return "", err
	}
	//
	cipherText, err := sm2.Encrypt(pubKey, contentBytes, rand.Reader, sm2.C1C3C2)

	return base64.StdEncoding.EncodeToString(cipherText), nil
}

//// Sm2DecryptLoc sm2私钥解密, 结果为base64格式
//func Sm2DecryptLoc(publicKeyStr, privateKeyStr, cipherText string) (string, error) {
//	publicKeyObj, err := StringToPublicKey(publicKeyStr)
//	if err != nil {
//		fmt.Println(err)
//	}
//	privateKeyObj, err := StringToPrivateKey(privateKeyStr, publicKeyObj)
//	if err != nil {
//		fmt.Println(err)
//	}
//	decodeString, err := hex.DecodeString(cipherText)
//	decrypt, err := sm2.Decrypt(privateKeyObj, decodeString, sm2.C1C2C3)
//	if err != nil {
//		fmt.Println(err)
//	}
//	resultStr := string(decrypt)
//	fmt.Println("解密后的字符串：", resultStr)
//	return resultStr, nil
//}

// StringToPrivateKey 私钥还原为 sm2.PrivateKey对象(与java中org.bouncycastle.crypto生成的公私钥完全互通使用)
func StringToPrivateKey(privateKeyStr string, publicKey *sm2.PublicKey) (*sm2.PrivateKey, error) {
	privateKeyBytes, err := hex.DecodeString(privateKeyStr)
	if err != nil {
		return nil, err
	}
	priHex := hex.EncodeToString(privateKeyBytes)

	// 将字节切片转换为大整数
	d := new(big.Int).SetBytes([]byte(priHex))

	// 创建 sm2.PrivateKey 对象
	privateKey := &sm2.PrivateKey{
		PublicKey: *publicKey,
		D:         d,
	}

	return privateKey, nil
}

// StringToPublicKey 公钥字符串还原为 sm2.PublicKey 对象(与java中org.bouncycastle.crypto生成的公私钥完全互通使用)
func StringToPublicKey(publicKeyStr string) (*sm2.PublicKey, error) {
	decodeString, err := base64.StdEncoding.DecodeString(publicKeyStr)
	if err != nil {
		return nil, err
	}
	public, err := x509.ReadPublicKeyFromHex(hex.EncodeToString(decodeString))
	if err != nil {
		return public, err
	}
	return public, nil
}