Go语言中OpenPGP公钥认证与数据加解密实践

package main

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

    "golang.org/x/crypto/openpgp"
    "golang.org/x/crypto/openpgp/armor" // 用于ASCII Armored格式
    "golang.org/x/crypto/openpgp/packet" // 用于密钥包操作
)

// generateKey 生成一个新的OpenPGP密钥对
func generateKey(name, email, comment string) (*openpgp.Entity, error) {
    config := &packet.Config{
        Rand:                   nil, // 使用默认的加密安全随机数生成器
        Time:                   nil, // 使用默认时间
        DefaultHash:            packet.SHA256,
        DefaultCipher:          packet.AES256,
        DefaultCompressionAlgo: packet.Zip,
    }
    entity, err := openpgp.NewEntity(name, comment, email, config)
    if err != nil {
        return nil, fmt.Errorf("failed to generate entity: %w", err)
    }

    // 为私钥设置密码 (可选，但推荐)
    // 如果不设置，私钥将没有密码保护
    // err = entity.PrivateKey.Encrypt([]byte("your-passphrase"))
    // if err != nil {
    //  return nil, fmt.Errorf("failed to encrypt private key: %w", err)
    // }

    // 至少有一个自签名，否则无法被信任
    for _, id := range entity.Identities {
        err := id.Sign(entity.PrivateKey, config)
        if err != nil {
            return nil, fmt.Errorf("failed to sign identity: %w", err)
        }
    }
    return entity, nil
}

// exportPublicKey 导出公钥到ASCII Armored格式
func exportPublicKey(entity *openpgp.Entity) (string, error) {
    buf := new(bytes.Buffer)
    w, err := armor.Encode(buf, openpgp.PublicKeyType, nil)
    if err != nil {
        return "", fmt.Errorf("failed to create armor encoder: %w", err)
    }
    err = entity.Serialize(w)
    if err != nil {
        return "", fmt.Errorf("failed to serialize entity: %w", err)
    }
    err = w.Close()
    if err != nil {
        return "", fmt.Errorf("failed to close armor writer: %w", err)
    }
    return buf.String(), nil
}

// encryptData 使用接收方的公钥加密数据
func encryptData(plaintext []byte, recipient *openpgp.Entity) ([]byte, error) {
    buf := new(bytes.Buffer)
    w, err := openpgp.Encrypt(buf, []*openpgp.Entity{recipient}, nil, nil, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to create encryption writer: %w", err)
    }
    _, err = w.Write(plaintext)
    if err != nil {
        return nil, fmt.Errorf("failed to write plaintext: %w", err)
    }
    err = w.Close()
    if err != nil {
        return nil, fmt.Errorf("failed to close encryption writer: %w", err)
    }
    return buf.Bytes(), nil
}

// decryptData 使用私钥解密数据
func decryptData(ciphertext []byte, keyring openpgp.KeyRing, passphrase []byte) ([]byte, error) {
    // openpgp.Decrypt需要一个Reader来读取密文
    // 如果私钥有密码，需要提供一个提示函数
    prompt := func(keys []openpgp.Key, mayTry bool) ([]byte, error) {
        if passphrase != nil {
            return passphrase, nil
        }
        return nil, fmt.Errorf("private key requires a passphrase")
    }

    md, err := openpgp.ReadMessage(bytes.NewReader(ciphertext), keyring, prompt, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to read encrypted message: %w", err)
    }

    plaintext, err := ioutil.ReadAll(md.UnverifiedBody)
    if err != nil {
        return nil, fmt.Errorf("failed to read decrypted body: %w", err)
    }
    return plaintext, nil
}

func main() {
    // 1. 生成发送方和接收方的密钥对
    sender, err := generateKey("Sender Name", "sender@example.com", "Sender Key")
    if err != nil {
        log.Fatalf("Error generating sender key: %v", err)
    }
    receiver, err := generateKey("Receiver Name", "receiver@example.com", "Receiver Key")
    if err != nil {
        log.Fatalf("Error generating receiver key: %v", err)
    }

    fmt.Printf("Sender Key ID: %X\n", sender.PrimaryKey.KeyId)
    fmt.Printf("Receiver Key ID: %X\n", receiver.PrimaryKey.KeyId)

    // 2. 模拟密钥环：接收方拥有自己的私钥和发送方的公钥
    // 在实际应用中，密钥环可能从文件或网络加载
    receiverKeyRing := openpgp.KeyRing([]*openpgp.Entity{receiver, sender})

    // 3. 查找密钥（通过Key ID）
    // 假设我们只知道接收方的Key ID，需要从KeyRing中找到对应的Entity
    foundRecipientEntity := receiverKeyRing.KeysById(receiver.PrimaryKey.KeyId)[0].Entity
    if foundRecipientEntity == nil {
        log.Fatalf("Recipient entity not found in keyring.")
    }
    fmt.Printf("Found recipient entity: %s\n", foundRecipientEntity.Identities[receiver.PrimaryKey.KeyIdString()].Name)


    // 4. 发送方使用接收方的公钥加密消息
    originalMessage := []byte("Hello, secure world! This is a secret message.")
    fmt.Printf("\nOriginal Message: %s\n", originalMessage)

    encryptedData, err := encryptData(originalMessage, foundRecipientEntity)
    if err != nil {
        log.Fatalf("Error encrypting data: %v", err)
    }
    fmt.Printf("Encrypted Data (first 50 bytes): %X...\n", encryptedData[:50])

    // 5. 接收方使用自己的私钥解密消息
    // 假设接收方知道自己的私钥密码（如果设置了）
    decryptedData, err := decryptData(encryptedData, receiverKeyRing, nil) // 如果私钥无密码，传nil
    if err != nil {
        log.Fatalf("Error decrypting data: %v", err)
    }
    fmt.Printf("Decrypted Message: %s\n", decryptedData)

    if !bytes.Equal(originalMessage, decryptedData) {
        log.Fatalf("Decrypted data does not match original!")
    }
    fmt.Println("Decryption successful and message matches original.")

    // 6. 导出并导入公钥示例 (模拟交换公钥)
    fmt.Println("\n--- Public Key Export/Import Example ---")
    senderPubKeyArmor, err := exportPublicKey(sender)
    if err != nil {
        log.Fatalf("Error exporting sender public key: %v", err)
    }
    fmt.Println("Sender Public Key (ARMOR):\n", senderPubKeyArmor)

    // 模拟接收方导入发送方的公钥
    keyringReader := bytes.NewReader([]byte(senderPubKeyArmor))
    entities, err := openpgp.ReadArmoredKeyRing(keyringReader)
    if err != nil {
        log.Fatalf("Error reading armored public key: %v", err)
    }
    if len(entities) > 0 {
        fmt.Printf("Successfully imported public key for: %s\n", entities[0].Identities[entities[0].PrimaryKey.KeyIdString()].Name)
    }
}