理解数字签名基础
数字签名是现代密码学中的一项关键技术，用于验证数字信息的真实性、完整性和不可否认性。它通过使用发送者的私钥对消息的哈希值进行加密，生成一个独特的签名。接收者可以使用发送者的公钥解密签名，并与自己计算的消息哈希值进行比对，从而确认消息来源的合法性以及消息在传输过程中是否被篡改。
Go语言的crypto/rsa包提供了RSA算法的实现，包括密钥生成、加密、解密以及数字签名和验证功能。其中，SignPKCS1v15和VerifyPKCS1v15函数是基于PKCS#1 v1.5标准的签名方案，广泛应用于各种安全通信场景。
RSA密钥对的生成与管理
在进行数字签名之前，首先需要生成一对RSA密钥：私钥（Private Key）用于签名，公钥（Public Key）用于验证。
package main
import (
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"encoding/pem"
"fmt"
"log"
"os"
)
// generateRSAKeyPair 生成指定位数的RSA密钥对
func generateRSAKeyPair(bits int) (*rsa.PrivateKey, *rsa.PublicKey, error) {
privateKey, err := rsa.GenerateKey(rand.Reader, bits)
if err != nil {
return nil, nil, fmt.Errorf("failed to generate RSA private key: %w", err)
}
return privateKey, &privateKey.PublicKey, nil
}
// savePrivateKeyToPEM 将私钥保存为PEM格式文件
func savePrivateKeyToPEM(privateKey *rsa.PrivateKey, filename string) error {
privatePEM := &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
}
return os.WriteFile(filename, pem.EncodeToMemory(privatePEM), 0600)
}
// savePublicKeyToPEM 将公钥保存为PEM格式文件
func savePublicKeyToPEM(publicKey *rsa.PublicKey, filename string) error {
publicKeyBytes, err := x509.MarshalPKIXPublicKey(publicKey)
if err != nil {
return fmt.Errorf("failed to marshal public key: %w", err)
}
publicPEM := &pem.Block{
Type: "PUBLIC KEY",
Bytes: publicKeyBytes,
}
return os.WriteFile(filename, pem.EncodeToMemory(publicPEM), 0644)
}
func main() {
// 生成2048位的RSA密钥对
privateKey, publicKey, err := generateRSAKeyPair(2048)
if err != nil {
log.Fatalf("Error generating keys: %v", err)
}
fmt.Println("RSA密钥对生成成功。")
// 示例：将密钥保存到文件
if err := savePrivateKeyToPEM(privateKey, "private.pem"); err != nil {
log.Fatalf("Error saving private key: %v", err)
}
if err := savePublicKeyToPEM(publicKey, "public.pem"); err != nil {
log.Fatalf("Error saving public key: %v", err)
}
fmt.Println("私钥已保存到 private.pem，公钥已保存到 public.pem")
// 实际应用中，你可能需要从文件中加载密钥
// loadPrivateKeyFromPEM("private.pem")
// loadPublicKeyFromPEM("public.pem")
}说明：
立即学习“go语言免费学习笔记（深入）”；
- rsa.GenerateKey(rand.Reader, bits)用于生成RSA私钥，rand.Reader是加密安全的随机数源，bits是密钥的长度（通常为2048或4096位）。
- x509.MarshalPKCS1PrivateKey和x509.MarshalPKIXPublicKey用于将私钥和公钥编码为标准的字节格式，以便进行PEM编码或存储。
- encoding/pem包用于将密钥编码为可读的PEM（Privacy-Enhanced Mail）格式，方便存储和传输。
消息的哈希处理
数字签名并非直接作用于原始消息，而是作用于消息的哈希值。这样做有几个优点：
- 效率： 哈希值通常比原始消息短得多，签名和验证过程更快。
- 安全性： 即使攻击者拥有签名，也难以从哈希值反推出原始消息。
- 固定长度： 无论消息多长，哈希值长度固定，简化了签名算法设计。
在Go语言中，可以使用crypto包下的各种哈希算法（如sha256、sha512等）来计算消息的哈希值。
import (
"crypto/sha256"
"encoding/json"
// ... 其他导入
)
// ExampleMessage 代表待签名的结构体消息
type ExampleMessage struct {
ID string `json:"id"`
Content string `json:"content"`
Timestamp int64 `json:"timestamp"`
}
// hashMessage 计算消息的SHA256哈希值
func hashMessage(msg ExampleMessage) ([]byte, error) {
// 将结构体序列化为字节切片
messageBytes, err := json.Marshal(msg)
if err != nil {
return nil, fmt.Errorf("failed to marshal message: %w", err)
}
// 计算SHA256哈希
hashed := sha256.Sum256(messageBytes)
return hashed[:], nil // 返回字节切片
}说明：
立即学习“go语言免费学习笔记（深入）”；
- 如果待签名消息是一个Go结构体，通常需要先将其序列化为字节切片（例如使用encoding/json、encoding/gob或protobuf等），然后再计算哈希。
- sha256.Sum256()返回一个[32]byte数组，需要通过切片操作hashed[:]将其转换为[]byte，以符合SignPKCS1v15和VerifyPKCS1v15的参数要求。
使用SignPKCS1v15进行签名
rsa.SignPKCS1v15函数用于使用私钥对消息的哈希值进行签名。
func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)
参数解释：
- rand io.Reader: 加密安全的随机数源，通常使用crypto/rand.Reader。在PKCS#1 v1.5签名方案中，随机性对于防止某些攻击至关重要。
- priv *rsa.PrivateKey: 用于签名的RSA私钥。
- hash crypto.Hash: 用于计算消息哈希的哈希算法标识。例如，如果使用SHA256，则传入crypto.SHA256。这个参数是为了确保签名和验签时使用相同的哈希算法，并为PKCS#1 v1.5填充方案提供算法标识。
- hashed []byte: 消息的哈希值字节切片。
示例代码：
package main
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"encoding/json"
"fmt"
"log"
"time"
)
// ExampleMessage 代表待签名的结构体消息
type ExampleMessage struct {
ID string `json:"id"`
Content string `json:"json"`
Timestamp int64 `json:"timestamp"`
}
func main() {
// 1. 生成RSA密钥对
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
log.Fatalf("Failed to generate RSA private key: %v", err)
}
publicKey := &privateKey.PublicKey
fmt.Println("RSA密钥对生成成功。")
// 2. 待签名消息
message := ExampleMessage{
ID: "order-12345",
Content: "Client ordered 5 units of product X.",
Timestamp: time.Now().Unix(),
}
// 3. 序列化消息并计算哈希值
messageBytes, err := json.Marshal(message)
if err != nil {
log.Fatalf("Failed to marshal message: %v", err)
}
fmt.Printf("原始消息 (JSON): %s\n", string(messageBytes))
hashed := sha256.Sum256(messageBytes)
fmt.Printf("消息哈希 (SHA256): %x\n", hashed[:])
// 4. 使用SignPKCS1v15进行签名
// 参数：rand.Reader (随机源), privateKey (私钥), crypto.SHA256 (哈希算法标识), hashed[:] (哈希值)
signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
if err != nil {
log.Fatalf("Failed to sign message: %v", err)
}
fmt.Printf("数字签名: %x\n", signature)
// ... 接下来进行验签
}使用VerifyPKCS1v15进行验签
rsa.VerifyPKCS1v15函数用于使用公钥验证数字签名的有效性。
func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error
参数解释：
- pub *rsa.PublicKey: 用于验证签名的RSA公钥。
- hash crypto.Hash: 用于计算消息哈希的哈希算法标识。必须与签名时使用的哈希算法一致。
- hashed []byte: 原始消息的哈希值字节切片。这通常是接收方独立计算的消息哈希。
- sig []byte: 待验证的数字签名字节切片。
示例代码（接上文）：
package main
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"encoding/json"
"fmt"
"log"
"time"
)
// ExampleMessage 代表待签名的结构体消息
type ExampleMessage struct {
ID string `json:"id"`
Content string `json:"content"`
Timestamp int64 `json:"timestamp"`
}
func main() {
// 1. 生成RSA密钥对
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
log.Fatalf("Failed to generate RSA private key: %v", err)
}
publicKey := &privateKey.PublicKey
fmt.Println("RSA密钥对生成成功。")
// 2. 待签名消息
message := ExampleMessage{
ID: "order-12345",
Content: "Client ordered 5 units of product X.",
Timestamp: time.Now().Unix(),
}
// 3. 序列化消息并计算哈希值
messageBytes, err := json.Marshal(message)
if err != nil {
log.Fatalf("Failed to marshal message: %v", err)
}
fmt.Printf("原始消息 (JSON): %s\n", string(messageBytes))
hashed := sha256.Sum256(message 
