Go语言RSA加密解密实战：从原理到工程化实现

1. 项目概述：为什么用Go实现RSA是每个后端工程师的必修课

最近在重构一个老项目的用户认证模块，发现其密码传输还在用Base64“加密”，这简直是把大门钥匙放在门垫下面。安全无小事，尤其是在数据即资产的今天。我决定用Go语言彻底重写核心的加密通信部分，而RSA非对称加密算法是构建安全体系的基石。网上虽然有很多代码片段，但要么是“玩具级”的实现，只讲原理无法投入生产；要么是直接调用标准库，知其然不知其所以然。这促使我动手，从零开始，结合Go的标准库 crypto/rsa 和 crypto/rand ，实现一个既深入原理、又具备工程实践价值的RSA加密解密工具包。

这个项目不仅仅是生成一对密钥然后调用 EncryptOAEP 就结束了。我会带你走完一个完整的闭环：从理解RSA的数学原理和安全性基础，到在Go中如何安全地生成超大素数（这是关键！），再到实现PKCS#1 v1.5和更安全的OAEP填充方案，最后处理密钥的序列化（PEM格式）与存储。你会发现，用Go实现RSA，不仅是调用几个API，更涉及到密码学安全、随机数生成、性能优化和错误处理等多方面的工程考量。无论你是需要为API接口添加签名验证，还是为配置文件加密敏感信息，或是构建一个安全的密钥交换流程，这套完整、可复现的源码和思路都能直接为你所用。

2. RSA算法核心原理与Go实现的关联

在动手写代码之前，我们必须搞清楚RSA到底在做什么。很多教程一上来就贴公式，让人望而生畏。我用一个“保险箱和公开投递口”的类比来解释：你打造了一个特制保险箱（生成密钥对）。这个保险箱有两把钥匙，一把是公钥，可以锁上箱子但无法打开；另一把是私钥，用于开锁。你把保险箱和公钥（锁）公开给全世界，任何人想给你传密信，就把信放进保险箱，用公钥锁上，然后寄给你。中途即使被截获，对方没有私钥也打不开。只有你手上有私钥，才能打开箱子取信。

这个类比对应到RSA的数学本质上，核心在于“大数分解的困难性”。算法步骤如下：

1. 选择两个大质数p和q ：这是所有安全的基础。在Go中，我们使用 crypto/rand 来生成密码学安全的随机数，进而生成这些大素数。 crypto/rsa 包中的 GenerateKey 函数帮我们完成了这个最复杂的步骤。
2. 计算模数n ： n = p * q 。n的长度（以比特为单位）就是我们常说的密钥长度，如2048位。n会被编码进公钥和私钥，是公开的。
3. 计算欧拉函数φ(n) ： φ(n) = (p-1) * (q-1) 。这个值必须严格保密，因为它直接关联到私钥。
4. 选择公钥指数e ：选择一个整数e，满足 1 < e < φ(n) ，且e与φ(n)互质（最大公约数为1）。通常使用65537（0x10001），因为它二进制表示中1很少，计算效率高，且安全性经过充分验证。
5. 计算私钥指数d ：计算e对于φ(n)的模反元素d，即满足 (e * d) mod φ(n) = 1 。d就是私钥的核心部分，必须绝对保密。

加密过程 ：对于明文消息m（需要先转换为一个整数，且 m < n ），计算密文 c = m^e mod n 。 解密过程 ：用私钥计算明文 m = c^d mod n 。

Go的 crypto/rsa 包完美封装了这些数学运算。但我们的实现不能只停留在调用 GenerateKey 。我们需要理解，为什么密钥长度至少要是2048位？因为目前公开破解768位RSA需要大量的计算资源，2048位被认为是未来多年内安全的底线。为什么填充方案如此重要？因为原始的RSA加密（教科书式RSA）存在多种攻击方式，比如通过加密猜测明文。这就需要引入填充（Padding）来增加随机性和安全性。

注意 ：绝对不要自己实现核心的数学运算（如模幂运算）。 crypto/rsa 包背后的实现经过了全球密码学专家的审查和优化，其正确性和抗侧信道攻击的能力远非个人实现可比。我们的工作是在此坚实基础上，构建易用、安全的应用程序接口。

3. 工程化实现：密钥生成、序列化与安全存储

理解了原理，我们开始动手构建。一个工程化的RSA工具，首要任务就是安全地生成密钥对并以合适的格式保存。Go的标准库已经提供了强大的支持。

3.1 安全生成RSA密钥对

在Go中，生成一个2048位的RSA密钥对非常简单，但背后的细节决定安全。

import (
    "crypto/rand"
    "crypto/rsa"
    "log"
)

func GenerateRSAKey(bits int) (*rsa.PrivateKey, error) {
    // 使用密码学安全的随机数生成器
    privateKey, err := rsa.GenerateKey(rand.Reader, bits)
    if err != nil {
        return nil, err
    }

    // 关键步骤：验证生成的密钥。这是一个重要的安全实践。
    err = privateKey.Validate()
    if err != nil {
        return nil, err
    }

    log.Printf("RSA-%d 密钥对生成成功。\n", bits)
    log.Printf("公钥指数 e: %d\n", privateKey.PublicKey.E)
    log.Printf("模数 n 的长度: %d bits\n", privateKey.PublicKey.N.BitLen())
    return privateKey, nil
}

实操心得 ：

• rand.Reader ：这是关键。务必使用 crypto/rand 这个密码学安全的随机数源。绝对不要用 math/rand ，它的随机性是伪随机且可预测的，会彻底摧毁密钥的安全性。
• Validate() ：调用此方法对生成的私钥进行基本的正确性验证，确保数学关系成立。这是一个低成本的安全检查。
• 密钥长度选择 ：对于新项目， 2048位是起步价 。如果你的系统需要保护有效期超过10年的数据，或者面临国家级攻击者的威胁，应考虑使用3072或4096位。记住，密钥长度翻倍，加解密性能会显著下降，需要权衡。

3.2 密钥的序列化与PEM格式

生成的密钥对象在内存中，我们需要将其持久化。最通用的格式是PEM（Privacy-Enhanced Mail）。PEM格式本质上是Base64编码的DER数据，加上特定的页眉和页脚。

import (
    "crypto/x509"
    "encoding/pem"
    "os"
)

func ExportPrivateKeyToPEM(privateKey *rsa.PrivateKey) ([]byte, error) {
    // 将私钥转换为PKCS#1 DER编码格式
    privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
    // 构建PEM块
    privateKeyPEM := pem.EncodeToMemory(&pem.Block{
        Type:  "RSA PRIVATE KEY", // PKCS#1格式的标识
        Bytes: privateKeyBytes,
    })
    return privateKeyPEM, nil
}

func ExportPublicKeyToPEM(publicKey *rsa.PublicKey) ([]byte, error) {
    // 将公钥转换为PKCS#1 DER编码格式
    publicKeyBytes := x509.MarshalPKCS1PublicKey(publicKey)
    // 构建PEM块
    publicKeyPEM := pem.EncodeToMemory(&pem.Block{
        Type:  "RSA PUBLIC KEY", // PKCS#1格式的标识
        Bytes: publicKeyBytes,
    })
    return publicKeyPEM, nil
}

// 保存到文件
func SaveKeyToFile(keyPEM []byte, filename string) error {
    return os.WriteFile(filename, keyPEM, 0600) // 注意文件权限：仅所有者可读写
}

注意事项 ：

• PKCS#1 vs PKCS#8 ：这里使用的是 MarshalPKCS1PrivateKey ，生成的是传统的PKCS#1格式。另一种更现代、更通用的格式是PKCS#8（类型为 PRIVATE KEY ），它可以用 x509.MarshalPKCS8PrivateKey 生成。一些新的系统（如某些Java库）可能更偏好PKCS#8。读取时，Go的 x509.ParsePKCS1PrivateKey 和 x509.ParsePKCS8PrivateKey 可以分别处理。
• 公钥格式 ：同样，公钥也有PKCS#1和X.509 SubjectPublicKeyInfo（SPKI）格式之分。上述代码生成PKCS#1公钥。更常见的格式可能是SPKI（类型为 PUBLIC KEY ），可通过 x509.MarshalPKIXPublicKey 生成。在实际交互中（如与OpenSSL、其他语言库），需要确认对方支持的格式。
• 文件权限 ：私钥文件权限设置为 0600 （仅所有者可读写）是 必须的 安全措施，防止服务器上其他用户或进程窃取。

3.3 从PEM文件加载密钥

加密解密时，我们需要从存储的PEM文件中重新加载密钥。

func LoadPrivateKeyFromPEMFile(filename string) (*rsa.PrivateKey, error) {
    keyData, err := os.ReadFile(filename)
    if err != nil {
        return nil, err
    }
    return ParsePrivateKeyFromPEM(keyData)
}

func ParsePrivateKeyFromPEM(keyPEM []byte) (*rsa.PrivateKey, error) {
    block, _ := pem.Decode(keyPEM)
    if block == nil {
        return nil, errors.New("failed to parse PEM block containing the key")
    }

    // 先尝试PKCS#1格式
    privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err == nil {
        return privateKey, nil
    }
    // 如果失败，尝试PKCS#8格式
    privateKeyInterface, err := x509.ParsePKCS8PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    // 类型断言
    var ok bool
    privateKey, ok = privateKeyInterface.(*rsa.PrivateKey)
    if !ok {
        return nil, errors.New("PEM block does not contain an RSA private key")
    }
    return privateKey, nil
}

func LoadPublicKeyFromPEMFile(filename string) (*rsa.PublicKey, error) {
    keyData, err := os.ReadFile(filename)
    if err != nil {
        return nil, err
    }
    return ParsePublicKeyFromPEM(keyData)
}

func ParsePublicKeyFromPEM(keyPEM []byte) (*rsa.PublicKey, error) {
    block, _ := pem.Decode(keyPEM)
    if block == nil {
        return nil, errors.New("failed to parse PEM block containing the key")
    }

    // 尝试PKCS#1格式
    publicKey, err := x509.ParsePKCS1PublicKey(block.Bytes)
    if err == nil {
        return publicKey, nil
    }
    // 尝试SPKI (X.509) 格式
    publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }
    var ok bool
    publicKey, ok = publicKeyInterface.(*rsa.PublicKey)
    if !ok {
        return nil, errors.New("PEM block does not contain an RSA public key")
    }
    return publicKey, nil
}

常见问题与排查 ：

• 错误：“RSA PUBLIC KEY not find”或“asn1: structure error” ：这几乎总是PEM格式不匹配导致的。首先检查PEM块的 Type 。如果是 PUBLIC KEY ，必须使用 ParsePKIXPublicKey ；如果是 RSA PUBLIC KEY ，则使用 ParsePKCS1PublicKey 。用文本编辑器打开PEM文件查看页眉页脚就能确认。
• 私钥加载失败 ：同样检查类型。 RSA PRIVATE KEY 对应 ParsePKCS1PrivateKey ， PRIVATE KEY 对应 ParsePKCS8PrivateKey 。上面的加载函数提供了自动尝试的健壮性写法，推荐在生产中使用。

4. 实现加密与解密：选择正确的填充方案

原始的RSA运算（教科书RSA）存在确定性（同样的明文永远产生同样的密文）和可预测性问题，容易受到选择明文攻击等。因此，在实际加密前，必须对明文进行“填充”（Padding），增加随机性和冗余。Go的 crypto/rsa 包主要支持两种填充方案：PKCS#1 v1.5 和 OAEP。

4.1 PKCS#1 v15 填充方案

这是较旧的填充标准，虽然目前在一些老系统中仍广泛使用，但已知存在一些潜在的攻击风险（如Bleichenbacher攻击）。除非需要与遗留系统兼容，否则建议使用更安全的OAEP。

import “crypto”

// 使用PKCS#1 v1.5填充进行加密
func EncryptPKCS1v15(publicKey *rsa.PublicKey, plaintext []byte) ([]byte, error) {
    // 计算最大加密长度。对于PKCS#1 v1.5，填充占用11字节。
    // 所以，明文最大长度 = 密钥长度(字节) - 11
    keySize := publicKey.Size()
    maxPlaintextLen := keySize - 11
    if len(plaintext) > maxPlaintextLen {
        // 对于长文本，需要采用分段加密，但更常见的做法是结合对称加密（见后文）。
        return nil, fmt.Errorf("plaintext too long: %d > %d", len(plaintext), maxPlaintextLen)
    }
    return rsa.EncryptPKCS1v15(rand.Reader, publicKey, plaintext)
}

// 使用PKCS#1 v1.5填充进行解密
func DecryptPKCS1v15(privateKey *rsa.PrivateKey, ciphertext []byte) ([]byte, error) {
    return rsa.DecryptPKCS1v15(rand.Reader, privateKey, ciphertext)
}

注意事项 ：

• 长度限制 ：PKCS#1 v1.5加密的明文长度受密钥长度限制。例如，2048位密钥（256字节），最多只能加密245字节的明文。这决定了它 不适合直接加密大量数据 ，通常用于加密一个随机的对称密钥（如AES密钥）。
• 确定性 ：虽然函数接受 rand.Reader 参数，但PKCS#1 v1.5的加密过程本身是确定性的（对于同一明文和公钥）。其安全性依赖于底层RSA问题的困难性。

4.2 OAEP填充方案（推荐）

OAEP（Optimal Asymmetric Encryption Padding）是一种更安全、可证明安全的填充方案。它引入了散列函数和随机种子，使得每次加密同一明文都会产生不同的密文，安全性更高。

// 使用OAEP填充进行加密
func EncryptOAEP(publicKey *rsa.PublicKey, plaintext []byte, label []byte) ([]byte, error) {
    // 计算最大加密长度。对于OAEP，填充占用 (2 * hash长度) + 2 字节。
    // 以SHA256为例：hash长度32字节，则填充占用 2*32+2=66字节。
    hash := crypto.SHA256
    keySize := publicKey.Size()
    hashSize := hash.New().Size()
    maxPlaintextLen := keySize - 2*hashSize - 2
    if len(plaintext) > maxPlaintextLen {
        return nil, fmt.Errorf("plaintext too long: %d > %d", len(plaintext), maxPlaintextLen)
    }
    return rsa.EncryptOAEP(hash.New(), rand.Reader, publicKey, plaintext, label)
}

// 使用OAEP填充进行解密
func DecryptOAEP(privateKey *rsa.PrivateKey, ciphertext []byte, label []byte) ([]byte, error) {
    hash := crypto.SHA256
    return rsa.DecryptOAEP(hash.New(), rand.Reader, privateKey, ciphertext, label)
}

核心参数解析 ：

• Hash函数 ： crypto.SHA256 是常用选择。也可以使用 crypto.SHA1 （强度较弱，不推荐新系统使用）或 crypto.SHA512 。加密和解密必须使用相同的Hash函数。
• Label参数 ：这是一个可选的、与明文关联的标签。在大多数简单用途下，可以传递 nil 。它的作用是允许在单个公钥下为不同上下文创建逻辑上独立的加密“通道”。加密和解密的 label 必须完全相同，否则解密会失败。
• 长度限制 ：OAEP的填充开销更大，因此能加密的明文更短。对于2048位密钥和SHA256，最多能加密 256 - 2*32 - 2 = 190 字节。这再次印证了RSA不适合直接加密大数据。

实操心得 ：

• 无脑选择OAEP ：在新项目中， 请始终优先使用OAEP 。除非你明确知道对接的系统只支持PKCS#1 v1.5。
• label的使用 ：虽然常设为 nil ，但在设计复杂协议时，合理使用 label 可以增加额外的安全维度。例如，可以用 label 来标识加密数据的用途（如 “user:auth_token” ），防止密文被误用到其他场景。

5. 处理长文本：RSA与对称加密的混合模式

由于RSA对加密数据长度的严格限制，在实际应用中，我们几乎从不直接用RSA加密业务数据（除非数据非常短，如一个密码或一个密钥）。标准的做法是采用 混合加密系统 ：

1. 生成一个随机的对称密钥 （例如，一个32字节的AES-256密钥）。
2. 使用这个对称密钥，用AES等算法加密你的实际数据（明文） 。AES等对称加密算法速度快，适合处理大体积数据。
3. 使用接收方的RSA公钥，加密上一步生成的对称密钥 。因为对称密钥长度固定且较短（如32字节），完全在RSA的加密能力范围内。
4. 将加密后的对称密钥和加密后的数据一起发送给接收方 。
5. 接收方用自己的RSA私钥解密出对称密钥，再用对称密钥解密出原始数据。

下面是一个完整的混合加密/解密示例：

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "io"
)

// HybridEncrypt 使用RSA公钥加密一个随机的AES密钥，并用该AES密钥加密明文。
func HybridEncrypt(publicKey *rsa.PublicKey, plaintext []byte) ([]byte, error) {
    // 1. 生成随机的AES-256密钥（32字节）
    aesKey := make([]byte, 32)
    if _, err := io.ReadFull(rand.Reader, aesKey); err != nil {
        return nil, err
    }

    // 2. 使用AES-GCM模式加密明文
    block, err := aes.NewCipher(aesKey)
    if err != nil {
        return nil, err
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    nonce := make([]byte, gcm.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }
    ciphertext := gcm.Seal(nil, nonce, plaintext, nil) // 这里可以添加额外的关联数据(AAD)

    // 3. 使用RSA-OAEP加密AES密钥
    encryptedAesKey, err := EncryptOAEP(publicKey, aesKey, nil)
    if err != nil {
        return nil, err
    }

    // 4. 组装最终密文：非对称加密的密钥长度是固定的，我们可以简单拼接。
    // 格式：[RSA加密的AES密钥长度(2字节)][RSA加密的AES密钥][AES-GCM的Nonce][AES-GCM加密的密文]
    result := make([]byte, 2+len(encryptedAesKey)+len(nonce)+len(ciphertext))
    binary.BigEndian.PutUint16(result[0:2], uint16(len(encryptedAesKey)))
    offset := 2
    copy(result[offset:], encryptedAesKey)
    offset += len(encryptedAesKey)
    copy(result[offset:], nonce)
    offset += len(nonce)
    copy(result[offset:], ciphertext)
    return result, nil
}

// HybridDecrypt 解密密文，还原明文。
func HybridDecrypt(privateKey *rsa.PrivateKey, data []byte) ([]byte, error) {
    // 1. 解析数据包
    if len(data) < 2 {
        return nil, errors.New("ciphertext too short")
    }
    encryptedAesKeyLen := int(binary.BigEndian.Uint16(data[0:2]))
    if len(data) < 2+encryptedAesKeyLen {
        return nil, errors.New("ciphertext malformed")
    }
    encryptedAesKey := data[2 : 2+encryptedAesKeyLen]
    offset := 2 + encryptedAesKeyLen

    // 2. 使用RSA私钥解密AES密钥
    aesKey, err := DecryptOAEP(privateKey, encryptedAesKey, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to decrypt AES key: %w", err)
    }

    // 3. 准备AES-GCM解密
    block, err := aes.NewCipher(aesKey)
    if err != nil {
        return nil, err
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    nonceSize := gcm.NonceSize()
    if len(data[offset:]) < nonceSize {
        return nil, errors.New("ciphertext too short for nonce")
    }
    nonce := data[offset : offset+nonceSize]
    ciphertext := data[offset+nonceSize:]

    // 4. 使用AES-GCM解密数据
    plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to decrypt data with AES-GCM: %w", err)
    }
    return plaintext, nil
}

方案优势与细节 ：

• 性能 ：对称加密（AES）速度极快，解决了RSA加密大数据慢的问题。
• 安全性 ：每次加密都使用全新的随机AES密钥和Nonce，即使同一明文多次加密，最终的密文也完全不同，提供了前向安全性。
• 数据包格式 ：示例中定义了一个简单的二进制格式来打包数据。在实际协议中（如TLS/PGP），格式会更复杂，包含版本号、算法标识等。这里的设计保证了接收方能明确地解析出各个部分。
• AES模式选择 ：使用了 AES-GCM 模式，因为它同时提供了加密和认证（完整性校验）。解密时 gcm.Open 会验证密文是否被篡改，比单纯的AES-CBC模式更安全。

6. 签名与验签：确保数据的完整性与来源

RSA的另一大用途是数字签名。它用于验证一段数据是否由持有对应私钥的人创建，并且在传输过程中未被篡改。过程与加密相反： 用私钥签名，用公钥验签 。

Go标准库同样提供了PKCS#1 v1.5和PSS（Probabilistic Signature Scheme）两种签名方案。PSS是更安全、随机化的方案，推荐使用。

import (
    "crypto"
    "crypto/sha256"
)

// 使用RSA-PSS签名
func SignPSS(privateKey *rsa.PrivateKey, data []byte) ([]byte, error) {
    // 1. 对原始数据计算哈希
    hashed := sha256.Sum256(data)
    // 2. 使用PSS选项进行签名
    // crypto.SHA256 指定了使用的哈希函数
    // &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthAuto} 让库自动选择盐值长度
    return rsa.SignPSS(rand.Reader, privateKey, crypto.SHA256, hashed[:], &rsa.PSSOptions{
        SaltLength: rsa.PSSSaltLengthAuto,
        Hash:       crypto.SHA256,
    })
}

// 验证RSA-PSS签名
func VerifyPSS(publicKey *rsa.PublicKey, data, signature []byte) error {
    hashed := sha256.Sum256(data)
    return rsa.VerifyPSS(publicKey, crypto.SHA256, hashed[:], signature, &rsa.PSSOptions{
        SaltLength: rsa.PSSSaltLengthAuto,
        Hash:       crypto.SHA256,
    })
}

// 使用传统的PKCS#1 v1.5签名（兼容性考虑）
func SignPKCS1v15(privateKey *rsa.PrivateKey, data []byte) ([]byte, error) {
    hashed := sha256.Sum256(data)
    return rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
}

func VerifyPKCS1v15(publicKey *rsa.PublicKey, data, signature []byte) error {
    hashed := sha256.Sum256(data)
    return rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hashed[:], signature)
}

关键点解析 ：

• 先哈希，再签名 ：RSA签名算法本身也对输入数据长度有限制。因此，标准做法是先对任意长度的原始数据计算一个固定长度的哈希值（如SHA256），然后对这个哈希值进行签名。这既解决了长度问题，也提高了效率。
• PSS选项 ： SaltLength: rsa.PSSSaltLengthAuto 是推荐设置。盐值（Salt）的加入使得每次对同一数据的签名结果都不同，增强了安全性。
• 验签的重要性 ：验签失败可能意味着：1) 数据被篡改；2) 签名不是用对应的私钥生成的；3) 签名算法或参数不匹配。在业务逻辑中，必须严格处理验签失败的情况。

7. 完整源码结构与使用示例

将上述所有功能模块化，形成一个完整的、可复用的Go包。下面是一个建议的项目结构：

rsa_crypto/
├── go.mod
├── main.go                    # 示例主程序
└── pkg/
    └── rsahelper/
        ├── rsahelper.go      # 核心结构体和函数
        ├── keygen.go         # 密钥生成与PEM导出导入
        ├── encrypt.go        # 加密解密函数 (PKCS#1v15, OAEP)
        ├── hybrid.go         # 混合加密解密函数
        ├── sign.go           # 签名验签函数
        └── errors.go         # 自定义错误类型

rsahelper.go 核心文件概览 ：

package rsahelper

import (
    "crypto/rsa"
    "fmt"
)

// RSAHelper 封装了RSA相关操作
type RSAHelper struct {
    PrivateKey *rsa.PrivateKey
    PublicKey  *rsa.PublicKey
}

// NewRSAHelperFromPEMFiles 从PEM文件创建Helper
func NewRSAHelperFromPEMFiles(privateKeyPath, publicKeyPath string) (*RSAHelper, error) {
    privKey, err := LoadPrivateKeyFromPEMFile(privateKeyPath)
    if err != nil {
        return nil, fmt.Errorf("load private key failed: %w", err)
    }
    pubKey, err := LoadPublicKeyFromPEMFile(publicKeyPath)
    if err != nil {
        return nil, fmt.Errorf("load public key failed: %w", err)
    }
    return &RSAHelper{PrivateKey: privKey, PublicKey: pubKey}, nil
}

// ... 其他包装方法，如 EncryptOAEP, DecryptOAEP, SignPSS 等，可以定义为RSAHelper的方法。

main.go 使用示例 ：

package main

import (
    "fmt"
    "log"
    "rsa_crypto/pkg/rsahelper"
)

func main() {
    // 1. 生成密钥对并保存
    privKey, err := rsahelper.GenerateRSAKey(2048)
    if err != nil {
        log.Fatal(err)
    }
    privPEM, _ := rsahelper.ExportPrivateKeyToPEM(privKey)
    pubPEM, _ := rsahelper.ExportPublicKeyToPEM(&privKey.PublicKey)
    _ = rsahelper.SaveKeyToFile(privPEM, "private.pem")
    _ = rsahelper.SaveKeyToFile(pubPEM, "public.pem")
    log.Println("密钥对已生成并保存。")

    // 2. 加载密钥
    helper, err := rsahelper.NewRSAHelperFromPEMFiles("private.pem", "public.pem")
    if err != nil {
        log.Fatal(err)
    }

    // 3. 混合加密示例
    message := "这是一段需要加密的敏感信息，可能很长很长..."
    fmt.Printf("原始明文: %s\n", message)

    ciphertext, err := rsahelper.HybridEncrypt(helper.PublicKey, []byte(message))
    if err != nil {
        log.Fatal("加密失败:", err)
    }
    fmt.Printf("加密后的密文 (Hex): %x...\n", ciphertext[:50])

    decrypted, err := rsahelper.HybridDecrypt(helper.PrivateKey, ciphertext)
    if err != nil {
        log.Fatal("解密失败:", err)
    }
    fmt.Printf("解密后的明文: %s\n", decrypted)

    // 4. 签名验签示例
    dataToSign := []byte("重要的合同条款")
    signature, err := rsahelper.SignPSS(helper.PrivateKey, dataToSign)
    if err != nil {
        log.Fatal("签名失败:", err)
    }
    fmt.Printf("签名结果 (Hex): %x\n", signature)

    err = rsahelper.VerifyPSS(helper.PublicKey, dataToSign, signature)
    if err != nil {
        log.Fatal("验签失败! 数据可能被篡改。")
    } else {
        log.Println("验签成功! 数据完整且来源可信。")
    }
}

8. 生产环境进阶考量与常见陷阱

将代码用于实际生产环境前，还有几个至关重要的坑需要避开。

8.1 密钥管理是核心

• 私钥存储 ：私钥绝不能硬编码在代码或配置文件里。应该存储在安全的密钥管理系统（KMS）中，如HashiCorp Vault、AWS KMS、或云原生的Secret管理服务。容器环境中，通过卷挂载或环境变量注入。
• 密钥轮换 ：制定密钥轮换策略。RSA密钥不应无限期使用。定期（如每年）生成新密钥对，并将旧密钥标记为“已弃用”，用于解密历史数据，新数据用新密钥加密。
• 公钥分发 ：公钥可以公开，但需要确保分发渠道可信，防止中间人替换公钥。通常通过HTTPS、数字证书等方式安全分发。

8.2 性能优化

• RSA很慢 ：RSA2048解密（私钥操作）在普通CPU上可能只有每秒几百次的操作能力。在高并发API签名验签场景下，这可能成为瓶颈。
  • 解决方案 ：1) 使用更快的硬件（如支持RSA加速的CPU）；2) 在网关或负载均衡器层面集中处理加解密；3) 对于非实时场景，采用异步或队列处理。
• 会话复用 ：对于频繁的对称加密操作（如HTTPS），TLS协议使用RSA握手一次，协商出对称密钥后，会复用该密钥一段时间，避免每次请求都做RSA运算。

8.3 错误处理必须严谨 密码学操作失败的原因很多：密文被篡改、密钥不匹配、填充错误、内存不足等。错误信息 绝不能 直接返回给客户端，以免泄露侧信道信息（如通过错误类型判断是填充错误还是密钥错误，这曾是Bleichenbacher攻击的基础）。

// 错误的做法
func BadDecrypt(ciphertext []byte) ([]byte, error) {
    plaintext, err := rsa.DecryptOAEP(..., ciphertext, ...)
    if err != nil {
        // 直接将具体的错误返回给调用者或日志，可能泄露信息
        return nil, fmt.Errorf("OAEP解密失败: %v", err)
    }
    return plaintext, nil
}

// 正确的做法：统一返回一个模糊的错误
var ErrDecryptionFailed = errors.New("decryption failed")

func SafeDecrypt(ciphertext []byte) ([]byte, error) {
    plaintext, err := rsa.DecryptOAEP(..., ciphertext, ...)
    if err != nil {
        // 记录详细的错误到服务器内部日志，便于排查
        log.Printf("内部错误: OAEP解密失败: %v", err)
        // 对外返回统一的、模糊的错误
        return nil, ErrDecryptionFailed
    }
    return plaintext, nil
}

8.4 算法与参数的选择

• 密钥长度 ： 2048位是当前最低安全要求 。新系统考虑3072位。1024位已不安全，绝对禁用。
• 哈希函数 ：与OAEP或PSS配合时，使用SHA256或SHA384。SHA1已遭破解，不应再使用。
• 填充方案 ：加密用OAEP，签名用PSS。PKCS#1 v1.5仅用于兼容旧系统。

8.5 测试与验证

• 单元测试 ：必须为所有核心函数编写单元测试，包括正常流程和异常情况（如错误格式的PEM、错误的密钥、超长明文等）。
• 与其他系统互操作性测试 ：如果你的Go服务需要与用Java、Python、C#等语言写的服务进行加解密或签名交互，务必进行端到端的测试，确保双方对密钥格式、填充方案、数据编码（如Base64）的理解完全一致。一个常见的做法是，用OpenSSL命令行工具生成密钥和测试数据，作为跨语言测试的“金标准”。

踩过这些坑之后，你会发现，实现RSA加密解密不仅仅是调用几个函数，它涉及从密码学原理、代码实现到系统架构和安全运维的一整套知识体系。这份完整的Go实现源码和配套的经验总结，希望能为你构建安全可靠的应用打下坚实的基础。在实际部署时，务必结合具体的业务场景和安全等级要求，进行充分的评审和测试。