Go语言OpenPGP库签名用户ID问题解析与实践

package main

import (
    "bytes"
    "fmt"
    "io"
    "log"

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

// SignPubKeyIdentity 使用私钥对公钥的用户ID进行签名
// asciiPub: 待签名的ASCII Armored公钥
// asciiPri: 用于签名的ASCII Armored私钥
// priPwd: 私钥的密码（如果私钥已加密）
// 返回: 包含新签名的ASCII Armored公钥
func SignPubKeyIdentity(asciiPub string, asciiPri string, priPwd string) (string, error) {
    // 1. 获取私钥实体
    signingEntity, err := getPrivateKeyEntity(asciiPri, priPwd)
    if err != nil {
        return "", fmt.Errorf("获取私钥实体失败: %w", err)
    }

    // 2. 获取公钥实体
    targetEntity, err := getPublicKeyEntity(asciiPub)
    if err != nil {
        return "", fmt.Errorf("获取公钥实体失败: %w", err)
    }

    // 3. 选择用户ID并签名
    // OpenPGP实体可以有多个用户ID，这里我们选择第一个用户ID进行签名。
    // 实际应用中可能需要根据特定逻辑选择。
    var userIdName string
    for _, identity := range targetEntity.Identities {
        userIdName = identity.Name
        break // 假设我们只签名第一个用户ID
    }

    if userIdName == "" {
        return "", fmt.Errorf("公钥实体中未找到用户ID可供签名")
    }

    // 核心签名操作：使用私钥实体对公钥实体的指定用户ID进行签名
    // nil参数表示不提供配置，使用默认配置
    err = targetEntity.SignIdentity(userIdName, signingEntity, nil)
    if err != nil {
        return "", fmt.Errorf("签名用户ID '%s' 失败: %w", userIdName, err)
    }

    // 4. 将包含新签名的公钥实体转换为ASCII Armor
    signedKeyArmor, err := entityToAsciiArmor(targetEntity, openpgp.PublicKeyType)
    if err != nil {
        return "", fmt.Errorf("将签名后的公钥实体转换为ASCII Armor失败: %w", err)
    }

    return signedKeyArmor, nil
}

// getPublicKeyEntity 从ASCII Armored字符串中解析出openpgp.Entity
func getPublicKeyEntity(asciiPub string) (*openpgp.Entity, error) {
    reader := bytes.NewReader([]byte(asciiPub))
    entityList, err := openpgp.ReadArmoredKeyRing(reader)
    if err != nil {
        return nil, fmt.Errorf("读取ASCII Armored公钥失败: %w", err)
    }
    if len(entityList) == 0 {
        return nil, fmt.Errorf("未从公钥字符串中解析出任何实体")
    }
    // 通常KeyRing中只有一个实体，这里直接返回第一个
    return entityList[0], nil
}

// getPrivateKeyEntity 从ASCII Armored字符串中解析出openpgp.Entity，并解密私钥
func getPrivateKeyEntity(asciiPri string, priPwd string) (*openpgp.Entity, error) {
    reader := bytes.NewReader([]byte(asciiPri))
    entityList, err := openpgp.ReadArmoredKeyRing(reader)
    if err != nil {
        return nil, fmt.Errorf("读取ASCII Armored私钥失败: %w", err)
    }
    if len(entityList) == 0 {
        return nil, fmt.Errorf("未从私钥字符串中解析出任何实体")
    }

    signingEntity := entityList[0] // 假设KeyRing中只有一个实体

    // 检查并解密私钥
    if signingEntity.PrivateKey == nil {
        return nil, fmt.Errorf("实体中不包含私钥")
    }
    if signingEntity.PrivateKey.Encrypted {
        if priPwd == "" {
            return nil, fmt.Errorf("私钥已加密但未提供密码")
        }
        err = signingEntity.PrivateKey.Decrypt([]byte(priPwd))
        if err != nil {
            return nil, fmt.Errorf("解密私钥失败: %w", err)
        }
    }
    // 确保所有子密钥也已解密（如果需要）
    for _, subkey := range signingEntity.Subkeys {
        if subkey.PrivateKey != nil && subkey.PrivateKey.Encrypted {
            err = subkey.PrivateKey.Decrypt([]byte(priPwd))
            if err != nil {
                return nil, fmt.Errorf("解密子私钥失败: %w", err)
            }
        }
    }

    return signingEntity, nil
}

// entityToAsciiArmor 将openpgp.Entity转换为ASCII Armored字符串
func entityToAsciiArmor(entity *openpgp.Entity, blockType string) (string, error) {
    buf := new(bytes.Buffer)
    writer, err := armor.Encode(buf, blockType, nil)
    if err != nil {
        return "", fmt.Errorf("创建Armor编码器失败: %w", err)
    }

    err = entity.Serialize(writer)
    if err != nil {
        return "", fmt.Errorf("序列化实体失败: %w", err)
    }
    err = writer.Close()
    if err != nil {
        return "", fmt.Errorf("关闭Armor编码器失败: %w", err)
    }

    return buf.String(), nil
}

func main() {
    // 替换为你的实际公钥和私钥
    // 注意：这里仅为演示，实际应用中请勿硬编码敏感信息。
    // 请确保你的私钥是合法的PGP私钥，并且公钥是合法的PGP公钥。
    // 可以使用`gpg --gen-key`生成测试用的密钥对。
    dummyPublicKey := `-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2

mQENBF+f+uMBCADqP92sY+66q2WwL1J0e0tGqV/0d0h4N0v7S6X2m5Nq15Fm0J/T
... (your public key here) ...
-----END PGP PUBLIC KEY BLOCK-----`

    dummyPrivateKey := `-----BEGIN PGP PRIVATE KEY BLOCK-----
Version: GnuPG v2

lQO+BF+f+uMBCADqP92sY+66q2WwL1J0e0tGqV/0d0h4N0v7S6X2m5Nq15Fm0J/T
... (your private key here) ...
-----END PGP PRIVATE KEY BLOCK-----`

    // 替换为你的私钥密码
    privateKeyPassword := "your_secret_password"

    signedKey, err := SignPubKeyIdentity(dummyPublicKey, dummyPrivateKey, privateKeyPassword)
    if err != nil {
        log.Fatalf("签名失败: %v", err)
    }

    fmt.Println("成功签名用户ID，生成的新公钥如下：")
    fmt.Println(signedKey)

    // 可以在此处将 signedKey 写入文件，然后使用 `gpg --check-sigs <filename>` 进行验证
    // 示例验证步骤 (假设保存为 signed_pubkey.asc):
    // 1. 将 signedKey 内容保存到文件 signed_pubkey.asc
    // 2. 运行 `gpg --import signed_pubkey.asc`
    // 3. 运行 `gpg --check-sigs <your_user_id_or_key_id>`
    // 如果签名有效，你应该会看到类似 "sig!  <key_id> <timestamp>" 的输出，表示签名良好。
}