当前位置：首页 > news >正文

Go项目配置安全实战：使用RSA非对称加密保护敏感信息

news 2026/7/1 5:06:36

1. 项目概述与核心痛点

在开发Go应用时，我们经常需要连接数据库、调用第三方API或者访问其他需要认证的服务。这些服务的密码、密钥等敏感信息，如果直接以明文形式写在config.yaml或.env这样的配置文件里，无异于把家门钥匙挂在门把手上。一旦代码仓库（即使是私有的）被泄露，或者服务器被入侵，这些敏感信息将直接暴露。这就是所谓的“硬编码”或“明文配置”的坑。我见过不少项目，为了图省事，直接把生产数据库的密码写死在代码里，后期维护和交接时风险极高。

这个实战项目的目标，就是解决这个痛点。我们不使用任何需要额外部署的复杂密钥管理服务（如HashiCorp Vault），而是采用一种轻量级、可移植性强的方案：使用RSA非对称加密算法来保护配置文件中的密码。核心思路是，将敏感的密码内容用公钥加密后存入配置文件，程序运行时用对应的私钥（妥善保管，不放入代码仓库）在内存中解密使用。这样，即使配置文件被公开，没有私钥也无法还原出原始密码。

这不仅仅是简单的“加密解密”调用。我们会深入探讨如何在Go项目中优雅地集成这套机制，包括密钥对的管理、加解密流程的设计、与现有配置解析库（如Viper）的融合，以及如何应对开发、测试、生产多环境的不同需求。整个过程，我会用我踩过的坑和总结的经验来填充，让你不仅能实现功能，更能理解背后的安全考量。

2. 技术选型与RSA原理浅析

2.1 为什么选择RSA而非对称加密？

面对加密需求，我们通常有对称加密（如AES）和非对称加密（如RSA）两种选择。

对称加密加解密使用同一个密钥，速度快，适合加密大量数据。但问题来了：这个密钥本身又该如何安全地存储和传递？如果把它放在代码或配置里，我们又回到了原点。

非对称加密则有一对密钥：公钥和私钥。公钥可以公开，用于加密数据；私钥必须严格保密，用于解密数据。这个特性完美契合我们的场景：

公钥可以交给任何需要加密密码的人（比如开发者），甚至可以放入代码仓库。他们用公钥加密密码后，将密文填入配置文件。
私钥则由部署应用的人（如运维人员）在生产服务器上妥善保管（如放在仅有应用有读取权限的文件中，或从环境变量注入）。程序运行时读取私钥来解密。
即使配置文件连同公钥一起泄露，攻击者没有私钥也无法解密出原始密码。

因此，RSA的非对称特性，从根本上解耦了“加密者”和“解密者”，解决了密钥分发和存储的难题。虽然RSA加解密速度比AES慢，但我们只加密密码这类短文本，性能开销完全可以忽略不计。

2.2 RSA密钥格式与Go标准库

在实操前，必须理清密钥格式，这是很多新手的第一道坎。RSA密钥主要有两种编码格式：PKCS#1和PKCS#8，以及两种存储形式：PEM和DER。

PKCS#1：传统格式，通常以-----BEGIN RSA PRIVATE KEY-----开头。
PKCS#8：更通用的格式，可以封装多种算法私钥，通常以-----BEGIN PRIVATE KEY-----开头（不包含“RSA”字样）。Go的crypto/rsa和crypto/x509包更倾向于处理PKCS#8格式。
PEM：是一种文本编码格式，将DER二进制数据用Base64编码，并加上头尾标识行，便于阅读和传输。我们常说的.pem文件就是这种。
DER：是二进制的编码格式。

Go的crypto/rsa包提供了核心的加解密函数，而crypto/x509包则负责密钥的编码解码（如解析PEM块、PKCS#1与PKCS#8的转换）。我们项目将主要使用这两个标准库，不引入额外的第三方加密库以保证简洁和安全。

注意：从OpenSSL等工具生成的密钥可能是PKCS#1格式，而Go的ParsePKCS8PrivateKey期望PKCS#8。直接读取可能会报错“不正确的长度”或“解析私钥失败”。我们需要进行格式转换。

3. 实战：生成与管理RSA密钥对

3.1 使用OpenSSL生成密钥对

虽然Go可以生成密钥，但在项目初期，用成熟的OpenSSL命令行工具生成密钥对更直观，也方便与运维流程集成。

生成PKCS#1格式的私钥（传统格式）：

# 生成一个2048位的RSA私钥，输出为PKCS#1 PEM格式 openssl genrsa -out private_key.pem 2048

查看private_key.pem，内容类似：

-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEA04upvaH6gYL... ...（Base64编码数据）... -----END RSA PRIVATE KEY-----

从私钥导出对应的公钥：

openssl rsa -in private_key.pem -pubout -out public_key.pem

生成的public_key.pem内容类似：

-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA04upvaH6gYL... ...（Base64编码数据）... -----END PUBLIC KEY-----

3.2 密钥格式转换（Go兼容性处理）

如前所述，Go的x509.ParsePKCS8PrivateKey更偏好PKCS#8格式。我们可以用OpenSSL将PKCS#1私钥转换为PKCS#8格式：

openssl pkcs8 -topk8 -inform PEM -in private_key.pem -out private_key_pkcs8.pem -nocrypt

-nocrypt参数表示输出的PKCS#8私钥不进行加密（即没有密码保护）。对于服务器端应用，我们通常使用无密码的私钥文件，但会通过文件系统权限（如chmod 600）来保护它。

转换后的private_key_pkcs8.pem文件头尾标识变为-----BEGIN PRIVATE KEY-----。

重要经验：我建议在项目中统一使用PKCS#8格式的PEM文件。将private_key_pkcs8.pem和public_key.pem妥善保存。私钥绝不能提交到代码仓库！应该通过.gitignore忽略，并通过安全的方式（如运维配置管理工具）分发到生产服务器。公钥则可以放入仓库，方便所有开发者加密配置。

3.3 在Go代码中生成密钥对（备选方案）

如果你的应用需要动态生成密钥对，也可以完全用Go实现：

package main import ( "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/pem" "errors" "os" ) // GenerateRSAKeyPair 生成RSA密钥对并保存到文件 func GenerateRSAKeyPair(bits int, privateKeyPath, publicKeyPath string) error { // 1. 生成私钥 privateKey, err := rsa.GenerateKey(rand.Reader, bits) if err != nil { return err } // 2. 编码私钥为PKCS#8 DER格式 privateKeyDER := x509.MarshalPKCS1PrivateKey(privateKey) // 注意：MarshalPKCS1PrivateKey返回的是PKCS#1格式。 // 若要PKCS#8，需使用 x509.MarshalPKCS8PrivateKey privateKeyBlock := &pem.Block{ Type: "RSA PRIVATE KEY", // PKCS#1 Bytes: privateKeyDER, } privateKeyFile, err := os.Create(privateKeyPath) if err != nil { return err } defer privateKeyFile.Close() if err := pem.Encode(privateKeyFile, privateKeyBlock); err != nil { return err } // 3. 生成公钥 publicKey := &privateKey.PublicKey publicKeyDER, err := x509.MarshalPKIXPublicKey(publicKey) if err != nil { return err } publicKeyBlock := &pem.Block{ Type: "PUBLIC KEY", Bytes: publicKeyDER, } publicKeyFile, err := os.Create(publicKeyPath) if err != nil { return err } defer publicKeyFile.Close() return pem.Encode(publicKeyFile, publicKeyBlock) } // 使用示例 func main() { err := GenerateRSAKeyPair(2048, "my_private.pem", "my_public.pem") if err != nil { panic(err) } }

这段代码生成的私钥是PKCS#1格式。如果你坚持要用Go生成PKCS#8，可以使用x509.MarshalPKCS8PrivateKey函数，并将PEM块的Type改为"PRIVATE KEY"。

4. 核心加解密工具类的实现

接下来，我们实现一个健壮的加解密工具类。这个类需要处理：从PEM文件加载密钥、用公钥加密字符串、用私钥解密字符串。

4.1 加载PEM格式的密钥

首先实现一个通用的函数来加载PEM文件并解析出RSA密钥。

package rsautil import ( "crypto/rsa" "crypto/x509" "encoding/pem" "errors" "io/ioutil" ) // LoadPublicKeyFromFile 从PEM文件加载RSA公钥 func LoadPublicKeyFromFile(filename string) (*rsa.PublicKey, error) { keyBytes, err := ioutil.ReadFile(filename) if err != nil { return nil, err } return ParsePublicKey(keyBytes) } // ParsePublicKey 从字节切片解析RSA公钥，支持PKCS#1和PKIX格式 func ParsePublicKey(keyBytes []byte) (*rsa.PublicKey, error) { block, _ := pem.Decode(keyBytes) if block == nil { return nil, errors.New("failed to parse PEM block containing the public key") } pub, err := x509.ParsePKIXPublicKey(block.Bytes) if err != nil { // 尝试解析为PKCS#1格式的公钥 pub, err := x509.ParsePKCS1PublicKey(block.Bytes) if err != nil { return nil, errors.New("failed to parse DER encoded public key: " + err.Error()) } return pub, nil } switch pub := pub.(type) { case *rsa.PublicKey: return pub, nil default: return nil, errors.New("not an RSA public key") } } // LoadPrivateKeyFromFile 从PEM文件加载RSA私钥 func LoadPrivateKeyFromFile(filename string) (*rsa.PrivateKey, error) { keyBytes, err := ioutil.ReadFile(filename) if err != nil { return nil, err } return ParsePrivateKey(keyBytes) } // ParsePrivateKey 从字节切片解析RSA私钥，优先尝试PKCS#8，然后尝试PKCS#1 func ParsePrivateKey(keyBytes []byte) (*rsa.PrivateKey, error) { block, _ := pem.Decode(keyBytes) if block == nil { return nil, errors.New("failed to parse PEM block containing the private key") } // 先尝试以PKCS#8格式解析 priv, err := x509.ParsePKCS8PrivateKey(block.Bytes) if err == nil { switch priv := priv.(type) { case *rsa.PrivateKey: return priv, nil default: return nil, errors.New("not an RSA private key in PKCS#8") } } // 如果PKCS#8解析失败，尝试PKCS#1格式 priv, err = x509.ParsePKCS1PrivateKey(block.Bytes) if err != nil { return nil, errors.New("failed to parse private key (both PKCS#8 and PKCS#1 attempts failed): " + err.Error()) } return priv, nil }

ParsePrivateKey函数体现了兼容性处理：先尝试通用的PKCS#8，失败了再尝试传统的PKCS#1。这能处理大多数由不同工具生成的私钥文件。

4.2 实现加密与解密函数

RSA加密有长度限制。对于2048位的密钥，能加密的明文长度受密钥长度和填充方案影响。直接加密长字符串会报错“message too long”。因此，标准做法是：用RSA加密一个随机生成的对称密钥（如AES密钥），再用这个对称密钥去加密实际数据。但对于密码这种短文本，我们可以使用更简单的OAEP填充方案，它安全性更高，且能加密的明文长度约为密钥长度/8 - 2*哈希长度 - 2。对于2048位密钥和SHA-256哈希，大约能加密190字节左右，对于密码绰绰有余。

package rsautil import ( "crypto/rand" "crypto/rsa" "crypto/sha256" "encoding/base64" "errors" ) // EncryptWithPublicKey 使用RSA公钥加密文本，返回Base64编码的密文 func EncryptWithPublicKey(plaintext string, publicKey *rsa.PublicKey) (string, error) { // 使用OAEP填充方案，增强安全性 label := []byte("") // 可选标签，通常为空 hash := sha256.New() ciphertext, err := rsa.EncryptOAEP(hash, rand.Reader, publicKey, []byte(plaintext), label) if err != nil { return "", err } // 转换为Base64字符串，便于放入YAML/JSON配置文件 return base64.StdEncoding.EncodeToString(ciphertext), nil } // DecryptWithPrivateKey 使用RSA私钥解密Base64编码的密文 func DecryptWithPrivateKey(ciphertextBase64 string, privateKey *rsa.PrivateKey) (string, error) { ciphertext, err := base64.StdEncoding.DecodeString(ciphertextBase64) if err != nil { return "", errors.New("failed to decode base64 ciphertext") } label := []byte("") hash := sha256.New() plaintext, err := rsa.DecryptOAEP(hash, rand.Reader, privateKey, ciphertext, label) if err != nil { return "", err } return string(plaintext), nil }

实操心得：一定要使用EncryptOAEP和DecryptOAEP，而不是旧的EncryptPKCS1v15。OAEP（Optimal Asymmetric Encryption Padding）是更安全、抵抗特定攻击的填充方案。虽然PKCS1v15更常见且兼容性极广，但在安全至上的场景下，OAEP是推荐选择。确保加密和解密使用相同的哈希函数（这里都是SHA256）。

5. 与项目配置管理集成（以Viper为例）

现在，我们有了加解密工具。下一步是如何将其无缝集成到项目的配置加载流程中。这里以流行的配置库Viper为例，展示如何实现一个“解密钩子”。

假设我们的配置文件config.yaml如下：

database: host: "localhost" port: 3306 username: "app_user" # 密码字段存储的是经过RSA公钥加密后的Base64密文 password_encrypted: "W0mNrOaBkPj4eG7QwILvK...（很长一串Base64）..." name: "myapp" redis: host: "127.0.0.1" password_encrypted: "fHjkL8uUJsdf...（另一串Base64）..."

我们的目标是：Viper加载配置后，自动识别*_encrypted后缀的字段，并用我们提供的私钥将其解密，然后将解密后的明文存入另一个字段（如password）供程序使用。

5.1 设计配置结构体与解密逻辑

首先定义配置结构体，并使用mapstructure标签（Viper内部使用）来映射字段。

package config import ( "log" "yourproject/pkg/rsautil" // 导入我们刚才写的工具包 "github.com/spf13/viper" ) type DatabaseConfig struct { Host string `mapstructure:"host"` Port int `mapstructure:"port"` Username string `mapstructure:"username"` // 注意：我们不直接映射 password_encrypted，而是通过后处理来解密 Password string `mapstructure:"password"` // 这个字段将由解密后的值填充 } type RedisConfig struct { Host string `mapstructure:"host"` Password string `mapstructure:"password"` } type AppConfig struct { Database DatabaseConfig `mapstructure:"database"` Redis RedisConfig `mapstructure:"redis"` // 可以添加其他配置节... }

然后，创建一个加载并解密配置的函数：

func LoadConfig(configPath, privateKeyPath string) (*AppConfig, error) { v := viper.New() v.SetConfigFile(configPath) // 指定配置文件路径 v.SetConfigType("yaml") // 如果文件扩展名不是.yaml，需要显式设置 if err := v.ReadInConfig(); err != nil { return nil, err } var cfg AppConfig if err := v.Unmarshal(&cfg); err != nil { return nil, err } // 关键步骤：加载私钥并解密加密字段 privateKey, err := rsautil.LoadPrivateKeyFromFile(privateKeyPath) if err != nil { return nil, err } // 解密数据库密码 if encryptedPass := v.GetString("database.password_encrypted"); encryptedPass != "" { decryptedPass, err := rsautil.DecryptWithPrivateKey(encryptedPass, privateKey) if err != nil { // 解密失败，可能是密钥不对或密文被篡改 log.Fatalf("Failed to decrypt database password: %v", err) } cfg.Database.Password = decryptedPass } else { // 如果没有加密字段，可以尝试读取明文字段（仅用于开发） cfg.Database.Password = v.GetString("database.password") } // 解密Redis密码 if encryptedPass := v.GetString("redis.password_encrypted"); encryptedPass != "" { decryptedPass, err := rsautil.DecryptWithPrivateKey(encryptedPass, privateKey) if err != nil { log.Fatalf("Failed to decrypt redis password: %v", err) } cfg.Redis.Password = decryptedPass } else { cfg.Redis.Password = v.GetString("redis.password") } return &cfg, nil }

5.2 更优雅的自动解密钩子

上面的方法需要在LoadConfig里显式处理每个加密字段。如果加密字段很多，会显得冗长。我们可以利用Viper的Unmarshal钩子功能，实现更通用的自动解密。

首先，定义一个实现了mapstructure.DecodeHookFunc接口的解密钩子：

package config import ( "reflect" "strings" "yourproject/pkg/rsautil" "github.com/mitchellh/mapstructure" ) // DecryptHookFunc 是一个mapstructure解码钩子，用于自动解密特定字段 func CreateDecryptHook(privateKey *rsa.PrivateKey) mapstructure.DecodeHookFunc { return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) { // 钩子只在从map（Viper内部表示）解码到结构体时生效 // 我们检查源数据是否是字符串，且目标类型也是字符串 if f.Kind() == reflect.String && t.Kind() == reflect.String { strData := data.(string) // 这里我们无法直接知道字段名。一个约定：在配置文件中，加密字段用特定后缀标识。 // 但钩子层面不知道字段名。因此，更通用的做法是在结构体标签中标记。 // 为了简化，我们假设Viper传过来的原始map的key是带后缀的。 // 实际上，更干净的方案是：先Unmarshal到一个中间结构体（包含*_encrypted字段）， // 然后在后处理步骤中遍历结构体，查找特定标签的字段进行解密。 // 鉴于篇幅，这里展示后处理遍历的思路。 return strData, nil // 钩子里不做解密，仅做类型转换 } return data, nil } }

更实用的做法是：先解析到一个包含所有可能加密字段的“原始”结构体，然后写一个后处理函数来解密。

type RawDatabaseConfig struct { Host string `mapstructure:"host"` Port int `mapstructure:"port"` Username string `mapstructure:"username"` PasswordEncrypted string `mapstructure:"password_encrypted"` PasswordPlain string `mapstructure:"password"` // 明文密码，仅用于开发/测试 } type RawAppConfig struct { Database RawDatabaseConfig `mapstructure:"database"` // ... 其他配置 } func LoadAndDecryptConfig(configPath, privateKeyPath string) (*AppConfig, error) { v := viper.New() // ... 读取配置 var rawCfg RawAppConfig if err := v.Unmarshal(&rawCfg); err != nil { return nil, err } privateKey, err := rsautil.LoadPrivateKeyFromFile(privateKeyPath) if err != nil { return nil, err } // 后处理解密逻辑 finalCfg := &AppConfig{} finalCfg.Database.Host = rawCfg.Database.Host finalCfg.Database.Port = rawCfg.Database.Port finalCfg.Database.Username = rawCfg.Database.Username // 优先级：加密字段 > 明文字段 if rawCfg.Database.PasswordEncrypted != "" { decrypted, err := rsautil.DecryptWithPrivateKey(rawCfg.Database.PasswordEncrypted, privateKey) if err != nil { return nil, err } finalCfg.Database.Password = decrypted } else { finalCfg.Database.Password = rawCfg.Database.PasswordPlain } return finalCfg, nil }

这种方式结构清晰，优先级明确，也便于记录日志（比如记录使用的是加密字段还是明文字段）。

6. 多环境配置与密钥管理策略

一个真实的项目会有开发、测试、生产等多个环境。我们的加密方案需要适配这种复杂性。

6.1 环境差异化管理

1. 开发/测试环境：

目标：方便快捷，避免每个开发者都要管理私钥。
方案：可以直接使用明文密码。可以通过环境变量APP_ENV=development来控制。
配置示例：在config.dev.yaml中，直接写password: "dev_password"，而不提供password_encrypted。在加载配置的逻辑中，判断如果是开发环境，则跳过解密步骤，直接使用明文字段。

2. 生产环境：

目标：安全第一。
方案：必须使用加密密码。配置文件只包含password_encrypted。私钥通过安全方式提供给应用。

实现思路：在配置加载函数中，增加环境判断。

func LoadConfig(configPath, privateKeyPath string) (*AppConfig, error) { env := os.Getenv("APP_ENV") isProd := env == "production" // ... 读取viper配置 if isProd { // 生产环境强制要求私钥和加密字段 if privateKeyPath == "" { log.Fatal("Private key path is required in production environment") } privateKey, err := rsautil.LoadPrivateKeyFromFile(privateKeyPath) // ... 解密逻辑 } else { // 非生产环境，允许使用明文回退 cfg.Database.Password = v.GetString("database.password") // 甚至可以输出警告，提示正在使用明文密码 log.Println("WARN: Running in non-production mode with plaintext password.") } return &cfg, nil }

6.2 私钥的安全存储与传递

这是整个方案最关键的环节。私钥绝不能出现在代码仓库或容器镜像中。

推荐方案：

文件系统权限：将私钥文件（如prod_private.pem）放在服务器上一个只有应用运行用户（如appuser）可读的目录（如/etc/app/secrets/）。设置严格的权限：chmod 600 /etc/app/secrets/prod_private.pem。
通过环境变量注入路径：应用通过环境变量APP_PRIVATE_KEY_PATH获取私钥文件路径。在Docker中，可以通过-v挂载卷将宿主机上的私钥文件挂载到容器内指定路径，并通过环境变量告知容器。

容器化部署（Docker）：

# Dockerfile FROM golang:alpine # ... 构建应用 # 不要COPY私钥文件 CMD ["./myapp"]

启动命令：

docker run -d \ -v /host/path/to/secrets:/run/secrets \ -e APP_PRIVATE_KEY_PATH=/run/secrets/prod_private.pem \ -e APP_ENV=production \ myapp:latest

Kubernetes：使用Kubernetes Secrets对象存储私钥，然后以卷或环境变量的方式挂载到Pod中。这是更云原生的做法。
绝对禁止：将私钥内容硬编码在环境变量值中（虽然可行，但命令行ps或一些监控工具可能泄露环境变量内容，风险较高）。文件形式更安全。

7. 配套工具：一个简单的配置加密CLI

为了让开发者和运维人员方便地加密密码，我们可以编写一个简单的命令行工具。

package main import ( "flag" "fmt" "log" "os" "yourproject/pkg/rsautil" ) func main() { var ( publicKeyPath string plaintext string outputFile string ) flag.StringVar(&publicKeyPath, "pub", "public_key.pem", "Path to RSA public key PEM file") flag.StringVar(&plaintext, "text", "", "The plaintext password to encrypt") flag.StringVar(&outputFile, "out", "", "Output file to write encrypted base64 text (default: stdout)") flag.Parse() if plaintext == "" { // 如果没有提供-text参数，尝试从第一个非标志参数读取 if flag.NArg() > 0 { plaintext = flag.Arg(0) } else { log.Fatal("Please provide plaintext to encrypt via -text flag or as an argument.") } } publicKey, err := rsautil.LoadPublicKeyFromFile(publicKeyPath) if err != nil { log.Fatalf("Failed to load public key: %v", err) } ciphertext, err := rsautil.EncryptWithPublicKey(plaintext, publicKey) if err != nil { log.Fatalf("Encryption failed: %v", err) } if outputFile != "" { err = os.WriteFile(outputFile, []byte(ciphertext), 0644) if err != nil { log.Fatal(err) } fmt.Printf("Encrypted text written to: %s\n", outputFile) } else { fmt.Println(ciphertext) } }

编译后，开发者可以这样使用：

# 加密数据库密码 ./config-encryptor -pub ./keys/public_key.pem -text "MySuperSecretDBP@ssw0rd!" # 输出一长串Base64，直接复制到配置文件的 password_encrypted 字段即可。 # 或者从文件读取密码（避免在命令行历史中留下记录） ./config-encryptor -pub ./keys/public_key.pem -text "$(cat db_password.txt)"

8. 常见问题、排查技巧与进阶思考

8.1 常见错误与排查

错误：x509: failed to parse private key或asn1: structure error
- 原因：私钥格式不对。最常见的是将PKCS#1格式的私钥试图用ParsePKCS8PrivateKey解析。
- 解决：使用我们上面提供的ParsePrivateKey函数，它兼容两种格式。或者用OpenSSL将私钥转换为PKCS#8格式：openssl pkcs8 -topk8 -inform PEM -in private.pem -out private_pkcs8.pem -nocrypt
错误：rsa: message too long
- 原因：尝试加密的明文数据长度超过了RSA密钥和填充方案所能处理的最大长度。
- 解决：确认你加密的是否是密码等短文本。如果是长文本，必须采用“RSA加密对称密钥，对称密钥加密数据”的混合加密方案。对于本项目场景，确保密码长度合理（通常不超过100字符）。
错误：解密失败，输出乱码或报错
- 原因1：公钥和私钥不匹配。确保你用来解密的私钥和用来加密的公钥是同一对。
- 原因2：密文在存储或传输中被修改（如配置文件格式错误，Base64编码损坏）。确保复制粘贴的密文完整无误，没有多余的空格或换行。YAML中多行字符串可以使用|或>符号。
- 排查：写一个简单的测试程序，用固定的密钥对加密一个已知字符串，再立即解密，看是否能成功。这可以隔离出是密钥问题还是配置加载问题。
程序启动时私钥文件找不到
- 原因：环境变量APP_PRIVATE_KEY_PATH设置错误，或文件路径权限问题。
- 解决：在应用启动日志中打印出尝试加载的私钥路径。确保运行应用的用户对该路径有读取权限。

8.2 性能与安全进阶思考

密钥长度：当前示例使用2048位RSA密钥，这在2023年及以后被认为是安全的底线。对于需要长期安全（超过10年）的系统，建议使用3072位或4096位的密钥。生成命令：openssl genrsa -out private_key.pem 4096。注意，密钥越长，加解密速度越慢，但对于密码加密仍可接受。
密钥轮换：任何密钥都不应永久使用。应制定密钥轮换策略。例如，每年生成新的密钥对。轮换时，需要：
- 用新公钥重新加密所有配置中的密码。
- 将新私钥安全地部署到所有服务器。
- 平滑切换，确保应用重启后能使用新私钥解密。
更复杂的场景：如果配置中需要加密的不仅仅是密码，还有连接字符串、令牌等，本方案同样适用。只需扩展配置结构体和后处理逻辑即可。
为什么不直接用环境变量？环境变量管理敏感信息也是一种常见做法。但环境变量有时会意外泄露（通过日志、错误报告、/proc文件系统等）。此外，对于复杂的配置（包含多个密码、密钥），全部放在环境变量中管理会变得笨拙。本方案结合了配置文件的结构化优势和环境变量的安全性思想（私钥类似环境变量管理）。
终极方案：对于大型分布式系统，应考虑使用专业的密钥管理服务（KMS），如AWS KMS、GCP Cloud KMS、HashiCorp Vault等。它们提供密钥生命周期管理、访问审计、自动轮换等高级功能。我们这里的RSA文件方案可以看作是一个轻量级、零依赖的KMS平替，适合中小型项目或作为过渡方案。