Go 语言的 RSA 加密与解密：方法与最佳实践
在对接支付业务时，RSA 算法是一个常见的选择。它是一种广泛应用于安全通信领域的非对称加密算法，使用一对密钥（公钥和私钥）来加密和解密数据，确保数据的安全性。在互联网通信、数字签名等场景中，RSA 算法具有重要作用。
本文将介绍如何在 Go 语言中使用 RSA 算法进行加密与解密。
一、RSA 加密与解密的基础知识
1. 非对称加密
RSA 是一种非对称加密算法，主要特点是密钥成对使用：一个用于加密（公钥），另一个用于解密（私钥）。使用公钥加密的数据只能用对应的私钥解密，反之亦然。这种特性使 RSA 特别适合于安全通信和数字签名。
2. 密钥生成
RSA 密钥由公钥和私钥组成。公钥可以公开，而私钥必须妥善保管。Go 提供了 crypto/rsa 和 crypto/rand 包，可以方便地生成和使用 RSA 密钥对。
二、RSA 加密与解密的实现
在 Go 中，使用 RSA 加密和解密的步骤包括：
- 生成 RSA 密钥对；
- 使用公钥加密数据；
- 使用私钥解密数据。
下面将逐步实现这些操作。
三、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()
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()
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) 填充方式，推荐使用 SHA-256 哈希函数。
// 使用公钥加密
func encryptWithPublicKey(msg string, pub *rsa.PublicKey) []byte {
ciphertext, err := rsa.EncryptOAEP(
sha256.New(),
rand.Reader,
pub,
[]byte(msg),
nil,
)
if err != nil {
fmt.Println("Encryption failed:", err)
return nil
}
return ciphertext
}
此代码使用公钥加密数据，确保数据安全。
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 {
plaintext, err := rsa.DecryptOAEP(
sha256.New(),
rand.Reader,
priv,
ciphertext,
nil,
)
if err != nil {
fmt.Println("Decryption failed:", err)
return ""
}
return string(plaintext)
}
此代码通过私钥解密加密数据。
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)
}
四、最佳实践
- 密钥安全：私钥必须严格保管，避免以明文形式存储在代码仓库中。推荐使用加密密钥库（如 AWS KMS、HashiCorp Vault 等）来保护密钥。
- OAEP Padding：在 RSA 加密中，应始终使用 OAEP 以抵御多种攻击。
- 密钥长度：使用至少 2048 位的密钥，建议 4096 位以增强安全性。
- 错误处理：在加密和解密过程中，务必注意错误处理，避免信息泄露。
- 避免直接加密大数据：RSA 不适合直接加密大量数据，通常使用对称加密（如 AES）加密数据，再用 RSA 加密对称密钥。
五、总结
本文介绍了如何在 Go 语言中实现 RSA 加密与解密，并给出了最佳实践，确保数据安全。在实际应用中，请根据具体需求合理使用 RSA 加密算法。