hcrypt

hcrypt

hcrypt 是一个加密解密工具库，提供 AES 和 RSA 加密算法的便捷封装，支持 GCM/CBC 模式、PKCS#1/OAEP 填充等多种加密方式。

功能特性

• AES-GCM 认证加密（推荐）
• AES-CBC 对称加密
• RSA 公钥加密/私钥解密
• 支持 PKCS#1 v1.5 和 OAEP 填充
• PEM 格式密钥解析
• PKCS#7 填充工具
• 加密安全随机数生成
• 便捷的字符串加密函数

导入路径

import "gitee.com/hwfo/hwf/pkg/hcrypt"

快速开始

简单字符串加密

package main

import (
    "fmt"
    "gitee.com/hwfo/hwf/pkg/hcrypt"
)

func main() {
    // 加密
    encrypted, _ := hcrypt.AESEncrypt("my-secret-key", "Hello, World!")
    fmt.Println("加密结果:", encrypted)
    
    // 解密
    decrypted, _ := hcrypt.AESDecrypt("my-secret-key", encrypted)
    fmt.Println("解密结果:", decrypted)
}

API 参考

AES 字符串加密（推荐）

// 加密字符串，返回 Base64 编码的密文
func AESEncrypt(keyStr, plaintext string) (string, error)

// 解密 Base64 编码的密文，返回原始字符串
func AESDecrypt(keyStr, ciphertextStr string) (string, error)

特点：

• 密钥可以是任意字符串（内部会 SHA256 哈希为 32 字节）
• 使用 AES-256-GCM 模式
• 返回 Base64 编码，便于传输和存储

// 示例
encrypted, _ := hcrypt.AESEncrypt("password123", "敏感数据")
decrypted, _ := hcrypt.AESDecrypt("password123", encrypted)

AES-GCM 加密

// GCM 加密（认证加密，推荐）
func AESGCMEncrypt(key, nonce, plaintext, aad []byte) (usedNonce, ciphertext []byte, err error)

// GCM 解密
func AESGCMDecrypt(key, nonce, ciphertext, aad []byte) ([]byte, error)

参数说明：

• key: AES 密钥（16/24/32 字节 → AES-128/192/256）
• nonce: 12 字节随机数，传 nil 自动生成
• aad: 附加认证数据（不加密但参与完整性校验，可为 nil）

// 生成随机密钥
key, _ := hcrypt.RandomBytes(32) // AES-256

// 加密
nonce, ciphertext, _ := hcrypt.AESGCMEncrypt(key, nil, []byte("明文"), nil)

// 解密
plaintext, _ := hcrypt.AESGCMDecrypt(key, nonce, ciphertext, nil)

AES-CBC 加密

// CBC 加密（带 PKCS#7 填充）
func AESCBCEncrypt(key, iv, plaintext []byte) (usedIV, ciphertext []byte, err error)

// CBC 解密
func AESCBCDecrypt(key, iv, ciphertext []byte) ([]byte, error)

key, _ := hcrypt.RandomBytes(32)

// 加密
iv, ciphertext, _ := hcrypt.AESCBCEncrypt(key, nil, []byte("明文"))

// 解密
plaintext, _ := hcrypt.AESCBCDecrypt(key, iv, ciphertext)

RSA 加密

// PKCS#1 v1.5 加密（兼容性好）
func RSAEncryptPKCS1v15(pubPEM, plaintext []byte) ([]byte, error)
func RSADecryptPKCS1v15(privPEM, ciphertext []byte) ([]byte, error)

// OAEP 加密（更安全）
func RSAEncryptOAEP(pubPEM, plaintext, label []byte) ([]byte, error)
func RSADecryptOAEP(privPEM, ciphertext, label []byte) ([]byte, error)

// 读取 PEM 格式的公钥和私钥
pubPEM := []byte(`-----BEGIN PUBLIC KEY-----
...
-----END PUBLIC KEY-----`)

privPEM := []byte(`-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----`)

// PKCS#1 v1.5 加密
ciphertext, _ := hcrypt.RSAEncryptPKCS1v15(pubPEM, []byte("明文"))
plaintext, _ := hcrypt.RSADecryptPKCS1v15(privPEM, ciphertext)

// OAEP 加密（推荐）
ciphertext, _ = hcrypt.RSAEncryptOAEP(pubPEM, []byte("明文"), nil)
plaintext, _ = hcrypt.RSADecryptOAEP(privPEM, ciphertext, nil)

工具函数

// 生成加密安全随机字节
func RandomBytes(n int) ([]byte, error)

// PKCS#7 填充
func PKCS7Pad(data []byte, blockSize int) []byte

// PKCS#7 去填充
func PKCS7Unpad(data []byte, blockSize int) ([]byte, error)

// 解析 PEM 格式公钥
func ParseRSAPublicKeyFromPEM(pemBytes []byte) (*rsa.PublicKey, error)

// 解析 PEM 格式私钥
func ParseRSAPrivateKeyFromPEM(pemBytes []byte) (*rsa.PrivateKey, error)

使用场景

用户密码重置 Token

// 生成加密的重置 Token
func GenerateResetToken(userID string) (string, error) {
    data := fmt.Sprintf("%s|%d", userID, time.Now().Unix())
    return hcrypt.AESEncrypt(secretKey, data)
}

// 验证重置 Token
func VerifyResetToken(token string) (string, error) {
    data, err := hcrypt.AESDecrypt(secretKey, token)
    if err != nil {
        return "", err
    }
    parts := strings.Split(data, "|")
    // 验证时间等...
    return parts[0], nil
}

敏感配置加密

// 加密配置
func EncryptConfig(config map[string]string) (string, error) {
    data, _ := json.Marshal(config)
    return hcrypt.AESEncrypt(masterKey, string(data))
}

// 解密配置
func DecryptConfig(encrypted string) (map[string]string, error) {
    data, err := hcrypt.AESDecrypt(masterKey, encrypted)
    if err != nil {
        return nil, err
    }
    var config map[string]string
    json.Unmarshal([]byte(data), &config)
    return config, nil
}

混合加密（大数据）

对于大量数据，推荐使用混合加密：用 RSA 加密 AES 密钥，用 AES 加密数据。

// 加密
func HybridEncrypt(pubPEM, data []byte) (encKey, nonce, ciphertext []byte, err error) {
    // 生成随机 AES 密钥
    aesKey, _ := hcrypt.RandomBytes(32)
    
    // RSA 加密 AES 密钥
    encKey, err = hcrypt.RSAEncryptOAEP(pubPEM, aesKey, nil)
    if err != nil {
        return
    }
    
    // AES 加密数据
    nonce, ciphertext, err = hcrypt.AESGCMEncrypt(aesKey, nil, data, nil)
    return
}

// 解密
func HybridDecrypt(privPEM, encKey, nonce, ciphertext []byte) ([]byte, error) {
    // RSA 解密 AES 密钥
    aesKey, err := hcrypt.RSADecryptOAEP(privPEM, encKey, nil)
    if err != nil {
        return nil, err
    }
    
    // AES 解密数据
    return hcrypt.AESGCMDecrypt(aesKey, nonce, ciphertext, nil)
}

注意事项

• AES-GCM 模式提供认证加密，推荐优先使用
• RSA 只适合加密少量数据（如密钥），大数据应使用混合加密
• 密钥应妥善保管，不要硬编码在代码中
• Nonce/IV 必须保存，解密时需要使用相同的值
• PEM 格式支持 "PUBLIC KEY"、"RSA PUBLIC KEY"、"PRIVATE KEY"、"RSA PRIVATE KEY"