Go 语言的 RSA 加密与解密：方法与最佳实践

一般对接过支付业务的都知道，RSA 算法。

RSA 是一种广泛应用于安全通信领域的非对称加密算法。

它使用一对密钥（公钥和私钥）来加密和解密数据，在互联网通信、数字签名等场景中具有重要作用。

咱们一起看一下，在 Go 语言中，如何使用 RSA 算法。

一、RSA 加密与解密的基础知识

1. 非对称加密

RSA 属于非对称加密算法，主要特点是密钥成对使用：一个用于加密（公钥），另一个用于解密（私钥）。

使用公钥加密的数据只能用对应的私钥解密，反之亦然。

这一特性使 RSA 非常适合用于安全通信和数字签名。

2. 密钥生成

RSA 密钥由公钥和私钥构成。公钥可以公开分发，而私钥必须严格保密。

Go 提供了 crypto/rsa 和 crypto/rand 包，允许我们生成和使用 RSA 密钥对。

二、RSA 加密与解密的实现

在 Go 中，实现 RSA 加密与解密涉及以下几个步骤：

1. 生成 RSA 密钥对。

2. 使用公钥加密数据。

3. 使用私钥解密数据。

下面，我们将依次实现这些操作。

三、RSA 加密与解密方法

1. 生成 RSA 密钥对

首先，我们需要生成一对 RSA 密钥。

可以使用 crypto/rsa 和 crypto/rand 包来完成这一步。

通常，密钥长度建议使用 2048 位及以上，以保证安全性。

package main

import (
 "crypto/rand"
 "crypto/rsa"
 "crypto/x509"
 "encoding/pem"
 "fmt"
 "os"
)

// 生成 RSA 密钥对并保存到文件中
func generateRSAKeyPair(bits int) (*rsa.PrivateKey, *rsa.PublicKey) {
 // 生成私钥
 privateKey, err := rsa.GenerateKey(rand.Reader, bits)
 if err != nil {
  fmt.Println("Failed to generate private key:", err)
  return nil, nil
 }

 // 通过私钥获取公钥
 publicKey := &privateKey.PublicKey

 // 保存私钥到文件
 savePEMKey("private.pem", privateKey)

 // 保存公钥到文件
 savePublicPEMKey("public.pem", publicKey)

 return privateKey, publicKey
}

// 将私钥保存到 PEM 文件
func savePEMKey(fileName string, key *rsa.PrivateKey) {
 file, err := os.Create(fileName)
 if err != nil {
  fmt.Println("Failed to create key file:", err)
  return
 }
 defer file.Close()

 // 将私钥编码为 PEM 格式
 privateKeyPEM := pem.EncodeToMemory(
  &pem.Block{
   Type:  "RSA PRIVATE KEY",
   Bytes: x509.MarshalPKCS1PrivateKey(key),
  },
 )

 file.Write(privateKeyPEM)
}

// 将公钥保存到 PEM 文件
func savePublicPEMKey(fileName string, pubkey *rsa.PublicKey) {
 file, err := os.Create(fileName)
 if err != nil {
  fmt.Println("Failed to create key file:", err)
  return
 }
 defer file.Close()

 // 将公钥编码为 PKIX 格式的 PEM
 pubKeyBytes, err := x509.MarshalPKIXPublicKey(pubkey)
 if err != nil {
  fmt.Println("Failed to marshal public key:", err)
  return
 }

 publicKeyPEM := pem.EncodeToMemory(
  &pem.Block{
   Type:  "PUBLIC KEY",
   Bytes: pubKeyBytes,
  },
 )

 file.Write(publicKeyPEM)
}

上述代码生成一对 RSA 密钥，并将私钥和公钥分别保存到 private.pem 和 public.pem 文件中。

密钥长度建议为 2048 或 4096 位，以确保安全性。

2. 使用公钥加密数据

使用公钥加密数据时，通常需要使用 crypto/rsa 包的 EncryptOAEP 函数，该函数基于 Optimal Asymmetric Encryption Padding (OAEP)：https://en.wikipedia.org/wiki/Optimal_Asymmetric_Encryption_Padding，提供了更高的安全性。

// 使用公钥加密
func encryptWithPublicKey(msg string, pub *rsa.PublicKey) []byte {
 // 使用公钥加密数据，采用 OAEP padding
 ciphertext, err := rsa.EncryptOAEP(
  sha256.New(),
  rand.Reader,
  pub,
  []byte(msg),
  nil,
 )
 if err != nil {
  fmt.Println("Encryption failed:", err)
  return nil
 }

 return ciphertext
}

在此示例中，使用 rsa.EncryptOAEP 进行加密，推荐使用 SHA-256 作为哈希函数，确保数据安全。

3. 使用私钥解密数据

要解密用公钥加密的数据，需要使用私钥。我们将使用 crypto/rsa 包中的 DecryptOAEP 函数来完成这一操作。

import (
 "crypto/sha256"
 "crypto/x509"
 "encoding/pem"
 "io/ioutil"
)

// 从 PEM 文件中加载私钥
func loadPrivateKey(fileName string) *rsa.PrivateKey {
 data, err := ioutil.ReadFile(fileName)
 if err != nil {
  fmt.Println("Failed to read private key file:", err)
  return nil
 }

 block, _ := pem.Decode(data)
 if block == nil || block.Type != "RSA PRIVATE KEY" {
  fmt.Println("Failed to decode PEM block containing private key")
  return nil
 }

 // 解析私钥
 privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
 if err != nil {
  fmt.Println("Failed to parse private key:", err)
  return nil
 }

 return privateKey
}

// 使用私钥解密
func decryptWithPrivateKey(ciphertext []byte, priv *rsa.PrivateKey) string {
 // 使用私钥解密数据，采用 OAEP padding
 plaintext, err := rsa.DecryptOAEP(
  sha256.New(),
  rand.Reader,
  priv,
  ciphertext,
  nil,
 )
 if err != nil {
  fmt.Println("Decryption failed:", err)
  return ""
 }

 return string(plaintext)
}

在这个示例中，我们使用 rsa.DecryptOAEP 函数和私钥解密数据，并将加密文本转换回明文。

4. 完整示例：加密和解密

func main() {
 // 生成密钥对
 privateKey, publicKey := generateRSAKeyPair(2048)

 // 原始消息
 message := "Hello, RSA!"

 // 使用公钥加密
 ciphertext := encryptWithPublicKey(message, publicKey)
 fmt.Printf("Encrypted message: %x\n", ciphertext)

 // 使用私钥解密
 plaintext := decryptWithPrivateKey(ciphertext, privateKey)
 fmt.Printf("Decrypted message: %s\n", plaintext)
}

四、最佳实践

1. 密钥安全：私钥必须妥善保存，绝不能以明文形式存储在代码仓库中。可以使用加密密钥库（如 AWS KMS、HashiCorp Vault 等）来保护密钥。

2. OAEP Padding：在 RSA 加密中，始终使用 OAEP（Optimal Asymmetric Encryption Padding）以抵御多种攻击。

3. 密钥长度：使用至少 2048 位的密钥长度，建议使用 4096 位以增强安全性。

4. 错误处理：在加密和解密过程中，注意检查并处理可能出现的错误，避免信息泄露。

5. 避免直接加密大数据：RSA 不适合直接加密大量数据。通常应将数据先用对称加密算法（如 AES）加密，再用 RSA 加密对称密钥。

五、最后

从密钥生成开始，介绍了如何进行公钥加密和私钥解密，并给出了最佳实践，以确保数据的安全性。

在实际应用中，请根据具体的安全要求合理使用 RSA。

最后，谢谢你看到了这里👏 想要第一时间接收到推送，可以点个关注。

可点击下方👇 关注公众号

添加作者微信 👇 获取原创学习资料