Go语言OpenPGP公钥加解密实践指南

package main

import (
    "bytes"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "os"

    "golang.org/x/crypto/openpgp"
    "golang.org/x/crypto/openpgp/armor"
)

// loadKeyRing 从文件加载一个OpenPGP密钥环
func loadKeyRing(filename string) (openpgp.EntityList, error) {
    keyringFileBuffer, err := os.Open(filename)
    if err != nil {
        return nil, fmt.Errorf("无法打开密钥文件: %w", err)
    }
    defer keyringFileBuffer.Close()

    // 尝试解析ASCII Armored格式
    block, err := armor.Decode(keyringFileBuffer)
    if err != nil {
        // 如果不是Armored格式，尝试直接作为二进制解析
        keyringFileBuffer.Seek(0, io.SeekStart) // 重置文件指针
        return openpgp.ReadKeyRing(keyringFileBuffer)
    }

    return openpgp.ReadKeyRing(block.Body)
}

// generateTestKeys 生成一对用于测试的OpenPGP密钥
func generateTestKeys(name, comment, email, passphrase string) (*openpgp.Entity, error) {
    entity, err := openpgp.NewEntity(name, comment, email, nil)
    if err != nil {
        return nil, fmt.Errorf("生成实体失败: %w", err)
    }

    // 为私钥设置口令
    for _, subkey := range entity.Subkeys {
        subkey.PrivateKey.Encrypt([]byte(passphrase))
    }
    entity.PrivateKey.Encrypt([]byte(passphrase))

    return entity, nil
}

func main() {
    // 示例：生成并保存测试密钥
    passphrase := "mysecretpassphrase"
    senderEntity, err := generateTestKeys("Sender", "Test Sender", "sender@example.com", passphrase)
    if err != nil {
        log.Fatalf("生成发送者密钥失败: %v", err)
    }
    recipientEntity, err := generateTestKeys("Recipient", "Test Recipient", "recipient@example.com", passphrase)
    if err != nil {
        log.Fatalf("生成接收者密钥失败: %v", err)
    }

    // 将密钥导出为Armored格式以模拟文件内容
    var senderPubKeyBuffer, senderPrivKeyBuffer, recipientPubKeyBuffer, recipientPrivKeyBuffer bytes.Buffer

    // 导出发送者公钥
    pubWriter, err := armor.Encode(&senderPubKeyBuffer, openpgp.PublicKeyType, nil)
    if err != nil { log.Fatalf("编码公钥失败: %v", err) }
    senderEntity.Serialize(pubWriter)
    pubWriter.Close()
    fmt.Printf("发送者公钥:\n%s\n", senderPubKeyBuffer.String())

    // 导出发送者私钥
    privWriter, err := armor.Encode(&senderPrivKeyBuffer, openpgp.PrivateKeyType, nil)
    if err != nil { log.Fatalf("编码私钥失败: %v", err) }
    senderEntity.SerializePrivate(privWriter, nil) // 私钥导出不带口令，加密在生成时已完成
    privWriter.Close()
    // fmt.Printf("发送者私钥:\n%s\n", senderPrivKeyBuffer.String()) // 敏感信息，通常不直接打印

    // 导出接收者公钥
    pubWriter, err = armor.Encode(&recipientPubKeyBuffer, openpgp.PublicKeyType, nil)
    if err != nil { log.Fatalf("编码公钥失败: %v", err) }
    recipientEntity.Serialize(pubWriter)
    pubWriter.Close()
    fmt.Printf("接收者公钥:\n%s\n", recipientPubKeyBuffer.String())

    // 导出接收者私钥
    privWriter, err = armor.Encode(&recipientPrivKeyBuffer, openpgp.PrivateKeyType, nil)
    if err != nil { log.Fatalf("编码私钥失败: %v", err) }
    recipientEntity.SerializePrivate(privWriter, nil)
    privWriter.Close()
    // fmt.Printf("接收者私钥:\n%s\n", recipientPrivKeyBuffer.String())

    // 模拟从文件加载密钥环
    // 在实际应用中，这里会调用 loadKeyRing("public.asc") 等
    // 为了演示，我们直接从内存中的 buffer 创建 EntityList
    senderPubRing, err := openpgp.ReadKeyRing(bytes.NewReader(senderPubKeyBuffer.Bytes()))
    if err != nil { log.Fatalf("加载发送者公钥环失败: %v", err) }
    recipientPubRing, err := openpgp.ReadKeyRing(bytes.NewReader(recipientPubKeyBuffer.Bytes()))
    if err != nil { log.Fatalf("加载接收者公钥环失败: %v", err) }
    recipientPrivRing, err := openpgp.ReadKeyRing(bytes.NewReader(recipientPrivKeyBuffer.Bytes()))
    if err != nil { log.Fatalf("加载接收者私钥环失败: %v", err) }

    fmt.Printf("\n加载的发送者公钥环包含 %d 个实体。\n", len(senderPubRing))
    fmt.Printf("加载的接收者公钥环包含 %d 个实体。\n", len(recipientPubRing))
    fmt.Printf("加载的接收者私钥环包含 %d 个实体。\n", len(recipientPrivRing))
}

// encryptMessage 使用接收者的公钥加密数据
func encryptMessage(plaintext []byte, recipientKeyRing openpgp.EntityList) ([]byte, error) {
    buf := new(bytes.Buffer)
    w, err := openpgp.Encrypt(buf, recipientKeyRing, nil, nil, nil) // 第三个参数是签名者，这里不签名
    if err != nil {
        return nil, fmt.Errorf("创建加密写入器失败: %w", err)
    }
    _, err = w.Write(plaintext)
    if err != nil {
        return nil, fmt.Errorf("写入明文失败: %w", err)
    }
    err = w.Close()
    if err != nil {
        return nil, fmt.Errorf("关闭加密写入器失败: %w", err)
    }
    return buf.Bytes(), nil
}

// 在 main 函数中添加加密示例
// ... (接上面的 main 函数)
func main() {
    // ... (密钥生成和加载部分)

    // 假设 recipientPubRing 已经加载了接收者的公钥
    // 假设 recipientPrivRing 已经加载了接收者的私钥

    message := []byte("这是一条需要加密的秘密消息。")
    fmt.Printf("\n原始消息: %s\n", string(message))

    // 使用接收者的公钥加密消息
    encryptedData, err := encryptMessage(message, recipientPubRing)
    if err != nil {
        log.Fatalf("加密消息失败: %v", err)
    }
    fmt.Printf("加密后的数据长度: %d 字节\n", len(encryptedData))
    // fmt.Printf("加密后的数据 (可能包含二进制): %x\n", encryptedData) // 不直接打印，可能包含不可见字符
}

// decryptMessage 使用私钥和密钥环解密数据
func decryptMessage(encryptedData []byte, privateKeyRing openpgp.EntityList, passphrase string) ([]byte, error) {
    // 解锁私钥
    for _, entity := range privateKeyRing {
        if entity.PrivateKey != nil && entity.PrivateKey.Encrypted {
            err := entity.PrivateKey.Decrypt([]byte(passphrase))
            if err != nil {
                // 尝试下一个密钥，或者返回错误
                // 这里为了简化，如果第一个私钥解锁失败就报错
                return nil, fmt.Errorf("解锁私钥失败: %w", err)
            }
        }
        for _, subkey := range entity.Subkeys {
            if subkey.PrivateKey != nil && subkey.PrivateKey.Encrypted {
                err := subkey.PrivateKey.Decrypt([]byte(passphrase))
                if err != nil {
                    return nil, fmt.Errorf("解锁子私钥失败: %w", err)
                }
            }
        }
    }

    md, err := openpgp.ReadMessage(bytes.NewReader(encryptedData), privateKeyRing, nil, nil)
    if err != nil {
        return nil, fmt.Errorf("读取加密消息失败: %w", err)
    }

    plaintext, err := ioutil.ReadAll(md.UnverifiedBody)
    if err != nil {
        return nil, fmt.Errorf("读取解密后的明文失败: %w", err)
    }

    return plaintext, nil
}

// 在 main 函数中添加解密示例
// ... (接上面的 main 函数)
func main() {
    // ... (密钥生成、加载和加密部分)

    // 使用接收者的私钥环和口令解密消息
    decryptedData, err := decryptMessage(encryptedData, recipientPrivRing, passphrase)
    if err != nil {
        log.Fatalf("解密消息失败: %v", err)
    }
    fmt.Printf("解密后的消息: %s\n", string(decryptedData))

    if string(message) == string(decryptedData) {
        fmt.Println("加密和解密成功，消息内容一致。")
    } else {
        fmt.Println("加密和解密失败，消息内容不一致。")
    }
}