func PKCS5Padding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(data, padtext...)
}

func PKCS5UnPadding(data []byte) []byte {
	length := len(data)
	// 去掉最后⼀個字節(jié) unpadding 次
	unpadding := int(data[length-1])
	return data[:(length - unpadding)]
}

func ZeroPadding(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize
	padtext := bytes.Repeat([]byte{0}, padding)
	return append(data, padtext...)
}

func ZeroUnPadding(data []byte) []byte {
	return bytes.TrimRightFunc(data, func(r rune) bool {
		return r == rune(0)
	})
}

//DES加密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func DesEncrypt(originalBytes, key []byte) ([]byte, error) {
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	originalBytes = PKCS5Padding(originalBytes, block.BlockSize())
	blockMode := cipher.NewCBCEncrypter(block, key)
	cipherArr := make([]byte, len(originalBytes))
	blockMode.CryptBlocks(cipherArr, originalBytes)
	return cipherArr, nil
}

//DES解密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func DesDecrypt(cipherBytes, key []byte) ([]byte, error) {
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockMode := cipher.NewCBCDecrypter(block, key)
	originalText := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(originalText, cipherBytes)
	originalText = PKCS5UnPadding(originalText)
	return originalText, nil
}

//DES加密⽂本，返回加密后⽂本
func DesEncryptString(originalText string, key []byte) (string, error) {
	cipherArr, err := DesEncrypt([]byte(originalText), key)
	if err != nil {
		return "", err
	}
	base64str := base64.StdEncoding.EncodeToString(cipherArr)
	return base64str, nil
}

//對加密⽂本進⾏DES解密，返回解密后明⽂
func DesDecryptString(cipherText string, key []byte) (string, error) {
	cipherArr, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherArr, err := DesDecrypt(cipherArr, key)
	if err != nil {
		return "", err
	}
	return string(cipherArr), nil
}

// 3DES加密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func TripleDesEncrypt(originalBytes, key []byte) ([]byte, error) {
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return nil, err
	}
	originalBytes = PKCS5Padding(originalBytes, block.BlockSize())
	// originalBytes = ZeroPadding(originalBytes, block.BlockSize())
	blockMode := cipher.NewCBCEncrypter(block, key[:8])
	cipherArr := make([]byte, len(originalBytes))
	blockMode.CryptBlocks(cipherArr, originalBytes)
	return cipherArr, nil
}

// 3DES解密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func TripleDesDecrypt(cipherBytes, key []byte) ([]byte, error) {
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return nil, err
	}
	blockMode := cipher.NewCBCDecrypter(block, key[:8])
	originalArr := make([]byte, len(cipherBytes))
	blockMode.CryptBlocks(originalArr, cipherBytes)
	originalArr = PKCS5UnPadding(originalArr)
	// origData = ZeroUnPadding(origData)
	return originalArr, nil
}

// 3DES加密字符串，返回base64處理后字符串
func TripleDesEncrypt2Str(originalText string, key []byte) (string, error) {
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return "", err
	}
	originalData := PKCS5Padding([]byte(originalText), block.BlockSize())
	// originalData = ZeroPadding(originalData, block.BlockSize())
	blockMode := cipher.NewCBCEncrypter(block, key[:8])
	cipherArr := make([]byte, len(originalData))
	blockMode.CryptBlocks(cipherArr, originalData)
	cipherText := base64.StdEncoding.EncodeToString(cipherArr)
	return cipherText, nil
}

// 3DES解密base64處理后的加密字符串，返回明⽂字符串
func TripleDesDecrypt2Str(cipherText string, key []byte) (string, error) {
	cipherArr, _ := base64.StdEncoding.DecodeString(cipherText)
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		return "", err
	}
	blockMode := cipher.NewCBCDecrypter(block, key[:8])
	originalArr := make([]byte, len(cipherArr))
	blockMode.CryptBlocks(originalArr, cipherArr)
	originalArr = PKCS5UnPadding(originalArr)
	// origData = ZeroUnPadding(origData)
	return string(originalArr), nil
}

//AES加密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func AesEncrypt(originalBytes, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	originalBytes = PKCS5Padding(originalBytes, blockSize)
	// originalBytes = ZeroPadding(originalBytes, block.BlockSize())
	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
	cipherBytes := make([]byte, len(originalBytes))
	// 根據(jù)CryptBlocks⽅法的說明，如下⽅式初始化crypted也可以
	// crypted := originalBytes
	blockMode.CryptBlocks(cipherBytes, originalBytes)
	return cipherBytes, nil
}

//AES解密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func AesDecrypt(cipherBytes, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
	originalBytes := make([]byte, len(cipherBytes))
	// origData := cipherBytes
	blockMode.CryptBlocks(originalBytes, cipherBytes)
	originalBytes = PKCS5UnPadding(originalBytes)
	// origData = ZeroUnPadding(origData)
	return originalBytes, nil
}

//AES加密⽂本，返回對加密后字節(jié)數(shù)組進⾏base64處理后字符串
func AesEncryptString(originalText string, key []byte) (string, error) {
	cipherBytes, err := AesEncrypt([]byte(originalText), key)
	if err != nil {
		return "", err
	}
	base64str := base64.StdEncoding.EncodeToString(cipherBytes)
	return base64str, nil
}

//AES解密⽂本，對Base64處理后的加密⽂本進⾏AES解密，返回解密后明⽂
func AesDecryptString(cipherText string, key []byte) (string, error) {
	cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)
	cipherBytes, err := AesDecrypt(cipherBytes, key)
	if err != nil {
		return "", err
	}
	return string(cipherBytes), nil
}

// 加密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func RsaEncrypt(publicKey, origData []byte) ([]byte, error) {
	block, _ := pem.Decode(publicKey)
	if block == nil {
		return nil, errors.New("public key error")
	}
	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	pub := pubInterface.(*rsa.PublicKey)
	return rsa.EncryptPKCS1v15(rand.Reader, pub, origData)
}

// 解密字節(jié)數(shù)組，返回字節(jié)數(shù)組
func RsaDecrypt(privateKey, ciphertext []byte) ([]byte, error) {
	block, _ := pem.Decode(privateKey)
	if block == nil {
		return nil, errors.New("private key error!")
	}
	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
}

// 加密字符串，返回base64處理的字符串
func RsaEncryptString(publicKey []byte, origData string) (string, error) {
	block, _ := pem.Decode(publicKey)
	if block == nil {
		return "", errors.New("public key error")
	}
	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return "", err
	}
	pub := pubInterface.(*rsa.PublicKey)
	cipherArr, err := rsa.EncryptPKCS1v15(rand.Reader, pub, []byte(origData))
	if err != nil {
		return "", err
	} else {
		return base64.StdEncoding.EncodeToString(cipherArr), nil
	}
}

// 解密經(jīng)過base64處理的加密字符串，返回加密前的明⽂
func RsaDecryptString(privateKey []byte, cipherText string) (string, error) {
	block, _ := pem.Decode(privateKey)
	if block == nil {
		return "", errors.New("private key error!")
	}
	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return "", err
	}
	cipherArr, _ := base64.StdEncoding.DecodeString(cipherText)
	originalArr, err := rsa.DecryptPKCS1v15(rand.Reader, priv, cipherArr)
	if err != nil {
		return "", err
	} else {
		return string(originalArr), nil
	}
}

// 加密
func EncryptOAEP(publicKey []byte, text string) (string, error) {
	block, _ := pem.Decode(publicKey)
	if block == nil {
		return "", errors.New("public key error")
	}

	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return "", err
	}

	pub := pubInterface.(*rsa.PublicKey)

	secretMessage := []byte(text)
	rng := rand.Reader
	cipherdata, err := rsa.EncryptOAEP(sha1.New(), rng, pub, secretMessage, nil)
	if err != nil {
		return "", err
	}
	ciphertext := base64.StdEncoding.EncodeToString(cipherdata)
	return ciphertext, nil
}

// 解密
func DecryptOAEP(privateKey []byte, ciphertext string) (string, error) {
	block, _ := pem.Decode(privateKey)
	if block == nil {
		return "", errors.New("private key error!")
	}

	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return "", err
	}

	cipherdata, _ := base64.StdEncoding.DecodeString(ciphertext)
	rng := rand.Reader
	plaintext, err := rsa.DecryptOAEP(sha1.New(), rng, priv, cipherdata, nil)
	if err != nil {
		return "", err
	}
	return string(plaintext), nil
}

//生成ECC橢圓曲線密鑰對
func GenerateECCKey() (*ecdsa.PublicKey, *ecdsa.PrivateKey, error) {
	privateKey, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
	if err != nil {
		return nil, nil, err
	}

	publicKey := privateKey.PublicKey
	return publicKey, privateKey, nil
}

//對消息的散列值生成數(shù)字簽名
func SignECC(msg []byte) ([]byte, []byte) {
	//取得私鑰
	_, privateKey, err := GenerateECCKey()
	if err != nil {
		panic(err)
	}

	//計算哈希值
	hash := sha256.New()

	//填入數(shù)據(jù)
	hash.Write(msg)
	b := hash.Sum(nil)

	//對哈希值生成數(shù)字簽名
	r, s, err := ecdsa.Sign(rand.Reader, privateKey, b)
	if err != nil {
		panic(err)
	}

	rtext, _ := r.MarshalText()
	stext, _ := s.MarshalText()
	return rtext, stext
}

//驗證數(shù)字簽名
func VerifySignECC(msg []byte, rtext, stext []byte) bool {
	//取得公鑰
	publicKey, _, err := GenerateECCKey()
	if err != nil {
		panic(err)
	}

	//計算哈希值
	hash := sha256.New()
	hash.Write(msg)
	b := hash.Sum(nil)

	//驗證數(shù)字簽名
	var r, s big.Int
	if err := r.UnmarshalText(rtext); err != nil {
		panic(err)
	}
	if err := s.UnmarshalText(stext); err != nil {
		panic(err)
	}

	verify := ecdsa.Verify(publicKey, b, r, s)
	return verify
}

//測試
func Test(t *testing.T) {
	//模擬發(fā)送者
	//要發(fā)送的消息
	msg := []byte("hello world")
	//生成數(shù)字簽名
	rtext, stext := SignECC(msg)

	//模擬接受者
	//接受到的消息
	acceptmsg := []byte("hello world")
	//接收到的簽名
	acceptrtext := rtext
	acceptstext := stext
	//驗證簽名
	verifySignECC := VerifySignECC(acceptmsg, acceptrtext, acceptstext)
	fmt.Println("驗證結(jié)果：", verifySignECC)
}

//⽣成私鑰和公鑰，⽣成的私鑰為結(jié)構(gòu)體ecdsa.PrivateKey的指針
func NewKeyPair() (ecdsa.PrivateKey, []byte) {
	//⽣成secp256橢圓曲線
	curve := elliptic.P256()
	//產(chǎn)⽣的是⼀個結(jié)構(gòu)體指針，結(jié)構(gòu)體類型為ecdsa.PrivateKey
	private, err := ecdsa.GenerateKey(curve, rand.Reader)
	if err != nil {
		log.Panic(err)
	}
	fmt.Printf("私鑰：%x\n", private)
	fmt.Printf("私鑰X：%x\n", private.X.Bytes())
	fmt.Printf("私鑰Y：%x\n", private.Y.Bytes())
	fmt.Printf("私鑰D：%x\n", private.D.Bytes())
	//x坐標(biāo)與y坐標(biāo)拼接在⼀起，⽣成公鑰
	pubKey := append(private.X.Bytes(), private.Y.Bytes()...)
	//打印公鑰，公鑰⽤16進制打印出來⻓度為128，包含了x軸坐標(biāo)與y軸坐標(biāo)。
	fmt.Printf("公鑰：%x \n", pubKey)
	return *private, pubKey
}

//⽣成簽名的DER格式
func MakeSignatureDerString(r, s string) string {
	// 獲取R和S的⻓度
	lenSigR := len(r) / 2
	lenSigS := len(s) / 2
	// 計算DER序列的總⻓度
	lenSequence := lenSigR + lenSigS + 4
	// 將10進制⻓度轉(zhuǎn)16進制字符串
	strLenSigR := DecimalToHex(int64(lenSigR))
	strLenSigS := DecimalToHex(int64(lenSigS))
	strLenSequence := DecimalToHex(int64(lenSequence))
	// 拼湊DER編碼
	derString := "30" + strLenSequence
	derString = derString + "02" + strLenSigR + r
	derString = derString + "02" + strLenSigS + s
	derString = derString + "01"
	return derString
}

func DecimalToHex(n int64) string {
	if n  0 {
		log.Println("Decimal to hexadecimal error: the argument must be greater than zero.")
		return ""
	}
	if n == 0 {
		return "0"
	}

	hex := map[int64]int64{10: 65, 11: 66, 12: 67, 13: 68, 14: 69, 15: 70}
	s := ""
	for q := n; q > 0; q = q / 16 {
		m := q % 16
		if m > 9  m  16 {
			m = hex[m]
			s = fmt.Sprintf("%v%v", string(m), s)
			continue
		}
		s = fmt.Sprintf("%v%v", m, s)
	}
	return s
}

//驗證簽名1
func VerifySig(pubKey, message []byte, r, s *big.Int) bool {
	curve := elliptic.P256()
	//公鑰的⻓度
	keyLen := len(pubKey)
	//前⼀半為x軸坐標(biāo)，后⼀半為y軸坐標(biāo)
	x := big.Int{}
	y := big.Int{}
	x.SetBytes(pubKey[:(keyLen / 2)])
	y.SetBytes(pubKey[(keyLen / 2):])
	rawPubKey := ecdsa.PublicKey{curve, x, y}
	//根據(jù)交易哈希、公鑰、數(shù)字簽名驗證成功。ecdsa.Verify func Verify(pub *PublicKey, hash[] byte, r * big.Int, s * big.Int) bool
	res := ecdsa.Verify(rawPubKey, message, r, s)
	return res
}

//驗證簽名2
func VerifySignature(pubKey, message []byte, r, s string) bool {
	curve := elliptic.P256()
	//公鑰的⻓度
	keyLen := len(pubKey)
	//前⼀半為x軸坐標(biāo)，后⼀半為y軸坐標(biāo)
	x := big.Int{}
	y := big.Int{}
	x.SetBytes(pubKey[:(keyLen / 2)])
	y.SetBytes(pubKey[(keyLen / 2):])
	rawPubKey := ecdsa.PublicKey{curve, x, y}
	//根據(jù)交易哈希、公鑰、數(shù)字簽名驗證成功。ecdsa.Verify func Verify(pub *PublicKey, hash[] byte, r * big.Int, s * big.Int) bool
	rint := big.Int{}
	sint := big.Int{}
	rByte, _ := hex.DecodeString(r)
	sByte, _ := hex.DecodeString(s)
	rint.SetBytes(rByte)
	sint.SetBytes(sByte)
	//fmt.Println("------", rint.SetBytes(rByte))
	//fmt.Println("------", sint.SetBytes(sByte))
	res := ecdsa.Verify(rawPubKey, message, rint, sint)
	return res
}

//驗證過程
func Test(t *testing.T) {
	//1、⽣成簽名
	fmt.Println("1、⽣成簽名-------------------------------")
	//調(diào)⽤函數(shù)⽣成私鑰與公鑰
	privKey, pubKey := NewKeyPair()
	//信息的哈希
	msg := sha256.Sum256([]byte("hello world"))
	//根據(jù)私鑰和信息的哈希進⾏數(shù)字簽名，產(chǎn)⽣r和s
	r, s, _ := ecdsa.Sign(rand.Reader, privKey, msg[:])
	//⽣成r、s字符串
	fmt.Println("-------------------------------")
	strSigR := fmt.Sprintf("%x", r)
	strSigS := fmt.Sprintf("%x", s)
	fmt.Println("r、s的10進制分別為：", r, s)
	fmt.Println("r、s的16進制分別為：", strSigR, strSigS)
	//r和s拼接在⼀起，形成數(shù)字簽名的der格式
	signatureDer := MakeSignatureDerString(strSigR, strSigS)
	//打印數(shù)字簽名的16進制顯示
	fmt.Println("數(shù)字簽名DER格式為：", signatureDer)
	fmt.Println()
	//2、簽名驗證過程
	fmt.Println("2、簽名驗證過程-------------------------------")
	res := VerifySig(pubKey, msg[:], r, s)
	fmt.Println("簽名驗證結(jié)果：", res)
	res = VerifySignature(pubKey, msg[:], strSigR, strSigS)
	fmt.Println("簽名驗證結(jié)果：", res)
}