Go中使用 x509.MarshalPKCS1PublicKey 生成RSA公钥

使用 Go 中的 x509.MarshalPKCS1PublicKey 生成 RSA 公钥时，作者遇到了问题。生成的公钥文件无法正确解析，原因可能是编组器中使用了错误的标签类型。经过调查，作者发现 x509 模块中的编组器与他们自己的编组器不同，导致了这个问题。通过使用自己的编组器，作者成功生成了有效的 ASN.1 文件，可以正确解析为 RSA 公钥。

我正在尝试从 go 生成公钥，如下所示：

reader := rand.reader
bitsize := 2048

keypair, err := rsa.generatekey(reader, bitsize)

这似乎有效并产生了一些有意义的东西。接下来，我想将其公共部分编写为 rsa 文件，如下所示：

func publickeytopembytes(prvkey *rsa.privatekey) ([]byte, error) {
    var pubkey *rsa.publickey
    pubkey = &prvkey.publickey

    pubkey_bytes := x509.marshalpkcs1publickey(pubkey)
    if pubkey_bytes == nil {
        return nil, errors.new("public key could not be serialized")
    }

    pubkey_pem := pem.encodetomemory(
        &pem.block{
            type:  "rsa public key",
            bytes: pubkey_bytes,
        },
    )

    return pubkey_pem, nil
}

这会生成一些看起来或多或少像您期望的东西。这是我生成的虚拟密钥，只是为了显示：

-----begin rsa public key-----
miibcgkcaqeamu6kirum2kacw7ishrvrvpxg5yc7+d58y26hv3tbhjcdnye9z8ne
s/xojs58scjl+6vlch03rqwflssbzrdtafge4v0ptzxq1ecuivx6eiuwaviktqa9
7webnfu4mchvlwfpuldaqofp02m2wxuci/dxchh1r2qjcjwzkauoerydop3+5yzi
cdhwx54t7giau6xv9m/5fh39eblvditk85/3rkrzib/6srbfskqvwpng69wjgizu
yjyqnnkb8qxg5vchrj+oxitbwxykfxbikuige8akudl9oi2sr5i0hq0amlnci9da
sght6uqgzmvrkjc9/fvklrqurlkmul1akwidaqab
-----end rsa public key-----

但实际上并不正确：

$ grep -v -- ----- < remote.pub  | base64 -d | dumpasn1 -
warning: input is non-seekable, some functionality has been disabled.
  0 264: sequence {
  4 257:   [application 2] {
       :       error: spurious eoc in definite-length item.

error: invalid data encountered at position 12: 4e 8a.

$ openssl asn1parse -in remote.pub 
    0:d=0  hl=4 l= 264 cons: sequence          
    4:d=1  hl=4 l= 257 cons: appl [ 2 ]        
    8:d=2  hl=2 l=  49 prim: eoc               
   59:d=2  hl=2 l=   8 prim: appl [ 11 ]       
   69:d=2  hl=2 l=  16 cons: appl [ 5 ]        
   71:d=3  hl=2 l=   0 prim: priv [ 19 ]       
error in encoding
140590716953024:error:0d07209b:asn1 encoding routines:asn1_get_object:too long:../crypto/asn1/asn1_lib.c:91:

它应该看起来像这样：

0 266: sequence {
  4 257:   integer
       :     00 fb 11 99 ff 07 33 f6 e8 05 a4 fd 3b 36 ca 68
       :     e9 4d 7b 97 46 21 16 21 69 c7 15 38 a5 39 37 2e
             ...
       :             [ another 129 bytes skipped ]
265   3:   integer 12345
       :   }

所以我认为我没有正确生成文件。 pkcs1.go 中的编组代码如下所示：

func marshalpkcs1publickey(key *rsa.publickey) []byte {
    derbytes, _ := asn1.marshal(pkcs1publickey{
        n: key.n,
        e: key.e,
    })
    return derbytes
}

我不知道这是如何工作的，但我认为它应该只生成一个包含两个整数的序列，其中一个是 n，另一个是 e。我不知道为什么 dumpasn1 认为它编码了一个 [应用程序 2] 但 dumpasn1 和 openssl 都不认为生成的内容是有效的 asn.1。

如果我正确理解 marshal 的文档，我认为 marshalpkcs1publickey 函数应该做正确的事情，但由于某种原因它没有。

我稍微看了一下编码。对于 openssl 生成的 rsa.pub 文件，它的开头是：

0000000 30 82 01 0a 02 82 01 01 00 fb 11 99 ff 07 33 f6

使用我的 go 方法，它会生成以下内容：

0000000 30 82 01 08 62 82 01 01 00 31 4e 8a 21 15 0c d8

我相信，其中的关键信息是它们生成 0x02（整数），但 go 方法生成 0x62。 0x62 标记是一个 application/constructed 整数，如此处所述。我不是这方面的专家，但我认为这就是问题所在。我认为它应该生成标签 0x02（整数），标签类型设置为 universal。

不过，这确实是我自己所能做到的。有人能告诉我哪里可能出轨了吗？

--克里斯

更新：pkcs1.go 中定义的公钥对象如下所示：

type pkcs1publickey struct {
    n *big.int
    e int
}

我想知道是否由于某种原因默认参数无法正常工作，因此我计划复制该结构并制作自己的编组方法。我的计划是在 n 和 e 上放置 asn1 字段标签，但在它以某种方式“修复”之前我没有做到这一点：

type mypublickey struct {
    n *big.int
    e int
}

func mymarshalpkcs1publickey(key *rsa.publickey) []byte {
    derbytes, _ := asn1.marshal(mypublickey{
        n: key.n,
        e: key.e,
    })
    return derbytes
}

所以我就是这样做的，猜猜看……如果我调用 mymarshalpkcs1publickey() 而不是 x509 中的那个，我最终会得到一个可以正确解析的 asn.1 文件。不仅如此

openssl rsa -RSAPublicKey_in -in mykey.pub -text

有效 - 它正确地输出模数和指数。

所以有些东西是不同的，即使我认为我只是使用相同代码的副本。我通过将对编组器的调用替换为对 x509 模块中的编组器的调用来确认这一点，然后它停止工作。我被难住了。

解决方案

我尝试重现您的问题，这对我有用......

考虑

package main

import "fmt"
import "crypto/rand"
import "crypto/rsa"
import "crypto/x509"
import "encoding/hex"
import (
    "encoding/pem"
    "log"
    "os"
)


func main() {
reader := rand.reader
bitsize := 64


keypair, _:= rsa.generatekey(reader, bitsize)

fmt.println("public key ", &keypair.publickey)

pubkey_bytes := x509.marshalpkcs1publickey(&keypair.publickey)

fmt.println(hex.dump(pubkey_bytes))

block := &pem.block{
        type: "message",
        bytes: pubkey_bytes ,
    }

    if err := pem.encode(os.stdout, block); err != nil {
        log.fatal(err)
    }

}

当你运行它时，控制台会显示

public key  &{14927333011981288097 65537}
00000000  30 10 02 09 00 cf 28 8a  49 37 1b 42 a1 02 03 01  |0.....(.i7.b....|
00000010  00 01                                             |..|

-----begin message-----
mbaccqdpkipjnxtcoqidaqab
-----end message-----

我使用https://asn1.io/asn1playground/

将其粘贴到架构中

world-schema definitions  ::= 
begin
 rsapublickey ::= sequence {
          modulus           integer,  -- n
          publicexponent    integer   -- e
      }                                
end

点击编译

将其粘贴到解码中

30 10 02 09 00 cf 28 8a  49 37 1b 42 a1 02 03 01 00 01

结果是

RSAPublicKey SEQUENCE: tag = [UNIVERSAL 16] constructed; length = 16
D0023E: Integer or enumerated value too long: 9; check field 'modulus' (type: INTEGER) of PDU #1 'RSAPublicKey'.
  modulus INTEGER: tag = [UNIVERSAL 2] primitive; length = 9
    2147483647
  publicExponent INTEGER: tag = [UNIVERSAL 2] primitive; length = 3
    65537
S0012E: Decoding of PDU #1 failed with the return code '10'.

我不知道为什么他们会发现错误，但序列和 2 个整数肯定在那里（你真的不需要工具来查看它） 编辑：error 与我们无关。

我使用https://base64.guru/converter/decode/hex检查go pem.encode生成的base64是否正确。

与您的代码的唯一区别是我使用的位大小（64而不是2048），因为它在https://play.golang.org/p/VQ7h9hYtO3W上有点长

今天关于《Go中使用 x509.MarshalPKCS1PublicKey 生成RSA公钥》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！