Go语言中RSA-SHA数字签名的正确实现与验证-Golang-PHP中文网

go语言中rsa-sha数字签名的正确实现与验证

本教程详细阐述了在Go语言中如何使用RSA-SHA算法进行数字签名与验证。文章将深入讲解签名与验证的正确流程，特别是区分了数字签名与加密操作，并纠正了常见的将验证误用为解密的错误。通过提供完整的Go代码示例，包括私钥签名和公钥验证的实现细节，帮助开发者掌握安全的数字签名实践。

引言：数字签名在Go语言中的重要性

在现代网络通信和数据存储中，确保数据的完整性、真实性和不可否认性至关重要。数字签名技术正是解决这些问题的核心手段之一。它允许消息的发送者对其内容进行“签名”，接收者则可以使用相应的公钥来验证签名的有效性，从而确认消息未被篡改且确实来源于声称的发送者。Go语言凭借其强大的标准库和简洁的并发模型，为实现安全的数字签名提供了坚实的基础。本文将聚焦于Go语言中RSA-SHA算法的数字签名与验证，并纠正一个常见的实现误区。

理解RSA-SHA数字签名原理

在深入Go语言实现之前，理解数字签名的基本原理是关键。

签名与加密的区别

首先，必须明确数字签名与加密是两个不同的概念，尽管它们都使用公钥/私钥对。

立即学习“go语言免费学习笔记（深入）”；

加密：旨在保护数据的机密性，确保只有拥有私钥的人才能解密并读取数据。
数字签名：旨在验证数据的完整性和发送者的身份。发送者使用私钥对数据进行签名，接收者使用公钥验证签名。签名后的数据本身并未加密，任何人都可以看到，但无法篡改且无法伪造。

原问题中将“验证”误解为“解密”是导致代码错误的核心原因。验证过程不是解密签名以获取原始数据，而是解密签名以获取原始消息的哈希值，然后与接收方独立计算的哈希值进行比对。

RSA-SHA签名与验证流程

以RSA-SHA256为例，其工作流程如下：

签名阶段（发送方）：
- 发送方对原始消息内容计算SHA256哈希值。
- 使用其RSA私钥对这个SHA256哈希值进行签名（实际上是使用私钥加密哈希值，但这里的“加密”是特定于签名的操作，而非通用数据加密）。
- 将原始消息和生成的数字签名一并发送给接收方。
验证阶段（接收方）：

腾讯智影-AI数字人
基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

73

查看详情
- 接收方收到原始消息和数字签名。
- 使用发送方的RSA公钥“解密”数字签名，得到一个哈希值（即发送方签名前的原始哈希值）。
- 接收方独立地对收到的原始消息内容计算SHA256哈希值。
- 比较两个哈希值：如果它们完全一致，则签名有效，表明消息未被篡改且确实由私钥持有者发出；否则，签名无效。

Go语言实现：RSA-SHA签名与验证

Go语言的crypto包提供了丰富的加密原语，使得实现RSA-SHA签名和验证变得相对简单。

核心库介绍

crypto/rsa: 实现了RSA算法。
crypto/sha256: 实现了SHA256哈希算法。
crypto/x509: 用于解析X.509格式的公钥和私钥证书。
encoding/pem: 用于PEM（Privacy-Enhanced Mail）格式的编码和解码，这是存储密钥的常见格式。
encoding/base64: 用于将二进制签名数据编码为字符串以便传输。
crypto/rand: 提供了密码学安全的随机数生成器，用于RSA签名过程。

密钥加载

首先，我们需要能够从PEM格式的文件中加载RSA私钥和公钥。

package main

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "errors"
    "fmt"
    "io/ioutil" // 注意：io/ioutil 在 Go 1.16+ 中已被弃用，推荐使用 os.ReadFile
    "log"
)

// Signer 接口定义了签名方法
type Signer interface {
    Sign(data []byte) ([]byte, error)
}

// Verifier 接口定义了验证方法
type Verifier interface {
    Verify(message, signature []byte) error
}

// rsaPrivateKey 包装了 *rsa.PrivateKey，并实现了 Signer 接口
type rsaPrivateKey struct {
    *rsa.PrivateKey
}

// rsaPublicKey 包装了 *rsa.PublicKey，并实现了 Verifier 接口
type rsaPublicKey struct {
    *rsa.PublicKey
}

// loadPrivateKey 从指定路径加载并解析PEM编码的私钥文件
func loadPrivateKey(path string) (Signer, error) {
    data, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("读取私钥文件失败: %w", err)
    }
    return parsePrivateKey(data)
}

// parsePrivateKey 解析PEM编码的私钥字节
func parsePrivateKey(pemBytes []byte) (Signer, error) {
    block, _ := pem.Decode(pemBytes)
    if block == nil {
        return nil, errors.New("未找到PEM块")
    }

    var rawkey interface{}
    switch block.Type {
    case "RSA PRIVATE KEY":
        rsaKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
        if err != nil {
            return nil, fmt.Errorf("解析PKCS1私钥失败: %w", err)
        }
        rawkey = rsaKey
    case "PRIVATE KEY": // 支持PKCS8格式的私钥
        rsaKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
        if err != nil {
            return nil, fmt.Errorf("解析PKCS8私钥失败: %w", err)
        }
        if pk, ok := rsaKey.(*rsa.PrivateKey); ok {
            rawkey = pk
        } else {
            return nil, fmt.Errorf("不支持的PKCS8私钥类型: %T", rsaKey)
        }
    default:
        return nil, fmt.Errorf("不支持的私钥类型 %q", block.Type)
    }

    return newSignerFromKey(rawkey)
}

// loadPublicKey 从指定路径加载并解析PEM编码的公钥文件
func loadPublicKey(path string) (Verifier, error) {
    data, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("读取公钥文件失败: %w", err)
    }
    return parsePublicKey(data)
}

// parsePublicKey 解析PEM编码的公钥字节
func parsePublicKey(pemBytes []byte) (Verifier, error) {
    block, _ := pem.Decode(pemBytes)
    if block == nil {
        return nil, errors.New("未找到PEM块")
    }

    var rawkey interface{}
    switch block.Type {
    case "PUBLIC KEY":
        rsaKey, err := x509.ParsePKIXPublicKey(block.Bytes)
        if err != nil {
            return nil, fmt.Errorf("解析PKIX公钥失败: %w", err)
        }
        if pk, ok := rsaKey.(*rsa.PublicKey); ok {
            rawkey = pk
        } else {
            return nil, fmt.Errorf("不支持的PKIX公钥类型: %T", rsaKey)
        }
    default:
        return nil, fmt.Errorf("不支持的公钥类型 %q", block.Type)
    }

    return newVerifierFromKey(rawkey)
}

// newSignerFromKey 根据给定的密钥接口创建 Signer 实例
func newSignerFromKey(k interface{}) (Signer, error) {
    switch t := k.(type) {
    case *rsa.PrivateKey:
        return &rsaPrivateKey{t}, nil
    default:
        return nil, fmt.Errorf("不支持的签名密钥类型 %T", k)
    }
}

// newVerifierFromKey 根据给定的密钥接口创建 Verifier 实例
func newVerifierFromKey(k interface{}) (Verifier, error) {
    switch t := k.(type) {
    case *rsa.PublicKey:
        return &rsaPublicKey{t}, nil
    default:
        return nil, fmt.Errorf("不支持的验证密钥类型 %T", k)
    }
}

登录后复制

签名实现

rsaPrivateKey的Sign方法负责计算消息的哈希值，并使用RSA私钥对其进行签名。这里我们使用rsa.SignPKCS1v15函数，它实现了PKCS #1 v1.5标准定义的签名方案。

// Sign signs data with rsa-sha256
func (r *rsaPrivateKey) Sign(data []byte) ([]byte, error) {
    h := sha256.New()
    h.Write(data)
    hashed := h.Sum(nil) // 计算原始数据的SHA256哈希

    // 使用rsa.SignPKCS1v15对哈希值进行签名
    return rsa.SignPKCS1v15(rand.Reader, r.PrivateKey, crypto.SHA256, hashed)
}

登录后复制

验证实现（关键修正）

这是原问题中错误发生的地方。rsaPublicKey的Verify方法应该使用rsa.VerifyPKCS1v15来验证签名，而不是尝试“解密”它。VerifyPKCS1v15函数接收公钥、哈希算法标识、原始消息的哈希值和签名本身，并返回一个错误。如果验证成功，则返回nil；否则，返回相应的错误。

// Verify verifies the message using a rsa-sha256 signature
func (r *rsaPublicKey) Verify(message []byte, signature []byte) error {
    h := sha256.New()
    h.Write(message)
    hashed := h.Sum(nil) // 计算原始消息的SHA256哈希

    // 使用rsa.VerifyPKCS1v15验证签名
    return rsa.VerifyPKCS1v15(r.PublicKey, crypto.SHA256, hashed, signature)
}

登录后复制

完整示例代码

以下是一个完整的Go程序，演示了如何使用上述函数进行RSA-SHA256签名和验证。

func main() {
    // 1. 加载私钥进行签名
    signer, err := loadPrivateKey("private.pem")
    if err != nil {
        log.Fatalf("加载私钥失败: %v", err)
    }

    toSign := "date: Thu, 05 Jan 2012 21:31:40 GMT"
    messageBytes := []byte(toSign)

    // 2. 对消息进行签名
    signedBytes, err := signer.Sign(messageBytes)
    if err != nil {
        log.Fatalf("签名失败: %v", err)
    }
    sigEncoded := base64.StdEncoding.EncodeToString(signedBytes)
    fmt.Printf("原始消息: %s\n", toSign)
    fmt.Printf("签名(Base64编码): %v\n", sigEncoded)

    // 3. 加载公钥进行验证
    verifier, err := loadPublicKey("public.pem")
    if err != nil {
        log.Fatalf("加载公钥失败: %v", err)
    }

    // 4. 验证签名
    // 注意：验证时需要原始消息内容和签名本身
    err = verifier.Verify(messageBytes, signedBytes)
    if err != nil {
        log.Fatalf("签名验证失败: %v", err)
    }

    fmt.Println("签名验证成功！")

    // 尝试篡改消息后验证
    fmt.Println("\n--- 尝试篡改消息后验证 ---")
    tamperedMessage := "date: Thu, 05 Jan 2012 21:31:41 GMT" // 篡改了一秒
    tamperedMessageBytes := []byte(tamperedMessage)
    err = verifier.Verify(tamperedMessageBytes, signedBytes)
    if err != nil {
        fmt.Printf("篡改消息后的验证失败 (预期结果): %v\n", err)
    } else {
        fmt.Println("篡改消息后的验证竟然成功了 (不应该发生)！")
    }

    // 尝试使用错误的签名进行验证 (例如，将签名最后一位改掉)
    fmt.Println("\n--- 尝试使用错误签名后验证 ---")
    if len(signedBytes) > 0 {
        badSignedBytes := make([]byte, len(signedBytes))
        copy(badSignedBytes, signedBytes)
        badSignedBytes[len(badSignedBytes)-1] ^= 0x01 // 翻转最后一位
        err = verifier.Verify(messageBytes, badSignedBytes)
        if err != nil {
            fmt.Printf("错误签名后的验证失败 (预期结果): %v\n", err)
        } else {
            fmt.Println("错误签名后的验证竟然成功了 (不应该发生)！")
        }
    }
}

登录后复制