gin 实现api接口数据非对称加密 ，并且生成非对称加密

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/base64"
	"encoding/pem"
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
	"os"
)

func main() {
	// 初始化Gin引擎
	r := gin.Default()
	// 生成非对称加密
	generateKeyPair()

	// 定义API接口
	r.POST("/encrypt", encryptHandler) // 加密数据失败
	r.POST("/decrypt", decryptHandler) // 解密数据失败

	// 启动 Gin 服务器
	r.Run(":8113")
}

func generateKeyPair() {
	// 生成 RSA 密钥对
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		fmt.Println("生成 RSA 密钥对失败:", err)
		return
	}
	publicKey := &privateKey.PublicKey
	// 保存私钥到文件（用于解密）
	privateKeyFile, err := os.Create("privateKey.pem")
	if err != nil {
		fmt.Println("保存私钥到文件失败:", err)
		return
	}
	defer privateKeyFile.Close()

	privateKeyPEM := &pem.Block{
		Type:  "PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
	}
	err = pem.Encode(privateKeyFile, privateKeyPEM)
	if err != nil {
		fmt.Println("保存私钥到文件失败:", err)
		return
	}

	// 保存公钥到文件（用于加密）
	publicKeyFile, err := os.Create("publicKey.pem")
	if err != nil {
		fmt.Println("保存公钥到文件失败:", err)
		return
	}
	defer publicKeyFile.Close()

	publicKeyPEM := &pem.Block{
		Type:  "PUBLIC KEY",
		Bytes: x509.MarshalPKCS1PublicKey(publicKey),
	}
	err = pem.Encode(publicKeyFile, publicKeyPEM)
	if err != nil {
		fmt.Println("保存公钥到文件失败:", err)
		return
	}
}

func encryptHandler(c *gin.Context) {
	data := c.PostForm("data")
	fmt.Println("====", data)

	privateKeyPath := "publicKey.pem"
	keyData, err := os.ReadFile(privateKeyPath)
	if err != nil {
		fmt.Println("加载私钥失败:", err)
		return
	}

	// 解析PEM格式的私钥
	block, _ := pem.Decode(keyData)
	if block == nil {
		fmt.Println("解析私钥失败")
		return
	}

	publicKey, err := x509.ParsePKCS1PublicKey(block.Bytes)
	if err != nil {
		fmt.Println("解析私钥失败")
		return
	}

	// 使用公钥加密数据
	encryptedData, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, []byte(data))
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "加密数据失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"encryptedData": encryptedData})
}

func decryptHandler(c *gin.Context) {
	encryptedDataStr := c.PostForm("encryptedData")
	if encryptedDataStr == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "加密数据不能为空"})
		return
	}

	// 解码加密数据
	encryptedData, err := base64.StdEncoding.DecodeString(encryptedDataStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "解码加密数据失败"})
		return
	}

	privateKeyPath := "privateKey.pem"
	keyData, err := os.ReadFile(privateKeyPath)
	if err != nil {
		fmt.Println("加载私钥失败:", err)
		return
	}

	// 解析PEM格式的私钥
	block, _ := pem.Decode(keyData)
	if block == nil {
		fmt.Println("解析私钥失败")
		return
	}

	privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		fmt.Println("解析私钥失败")
		return
	}

	// 使用私钥解密数据
	decryptedData, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, encryptedData)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "解密数据失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"decryptedData": string(decryptedData)})
}