为什么在 Golang 中将 DER ASN.1 大整数的解组限制为 SEQUENCE？

Question

我希望能够使用 encoding/asn1 包从 DER 文件中解组一个大整数，但它看起来只适用于整数序列。

例如，这不起作用，这很奇怪，因为 Big Int 的编组效果很好 (https://play.golang.org/p/Wkj0jAA6bpq) :

package main

import (
    "encoding/asn1"
    "fmt"
    "math/big"
)


func main() {
        r, _ := new(big.Int).SetString("481B6A0913BD8024CA5D22F014F3", 16);
        encoding, _  := asn1.Marshal(r) 
        fmt.Printf("% X\n", encoding)               // Displayed as an integer: 02 0E 48 1B 6A 09 13 BD 80 24 CA 5D 22 F0 14 F3
        var t big.Int
        _, err := asn1.Unmarshal(encoding, &t)
        if err != nil {
            fmt.Println("Erreur unmarshalling -", err)  // asn1: structure error: tags don't match
        }   
        fmt.Println(t.String())
}

看起来只有当它是 SEQUENCE 的一部分时我才能解组一个大整数，如本例所示：https://play.golang.org/p/J93afvbk41L

package main

import (
    "encoding/asn1"
    "fmt"
    "math/big"
)

type TestBigInt struct {                    // From encoding/asn1/asn1_test.go
    X *big.Int
}

func main() {
        r, _ := new(big.Int).SetString("481B6A0913BD8024CA5D22F014F3", 16);
        encoding, _  := asn1.Marshal(TestBigInt{r}) 
        fmt.Printf("% X\n", encoding)               // Displayed as a sequence of an integer: 30 10 02 0E 48 1B 6A 09 13 BD 80 24 CA 5D 22 F0 14 F3
        var t TestBigInt
        _, err := asn1.Unmarshal(encoding, &t)
        if err != nil {
            fmt.Println("Erreur unmarshalling -", err)  
        }   
        fmt.Println(t.X.String())
}

但是，它适用于 64 位整数的 32 位，如本例所示：https://play.golang.org/p/vcIgWrI-sk-

package main

import (
    "encoding/asn1"
    "fmt"
)

func main() {
        r := 12234
        encoding, _ := asn1.Marshal(r)
        fmt.Printf("% X\n", encoding)
        var t int
        _, err := asn1.Unmarshal(encoding, &t)
        if err != nil {
            fmt.Println("Erreur unmarshalling -", err)
        }   
        fmt.Println(t)
}

这是 encoding/asn1 包的已知限制吗？解编序列外的大整数的任何已知解决方案？

Answer 1

文档指出：

An ASN.1 INTEGER can be written to an int, int32, int64, or *big.Int (from the math/big package).

请注意，第四个选项是 *big.Int，而不是 big.Int。由于自动类型推导，您看不到它，但前者实际上与第一个示例中的 r 类型相同，更清楚的是第二个示例中的 X 类型。

如果您将变量更改为指针，那么它应该可以工作。例如修改你的第一个例子：

package main

import (
    "encoding/asn1"
    "fmt"
    "math/big"
)


func main() {
        r, _ := new(big.Int).SetString("481B6A0913BD8024CA5D22F014F3", 16);
        encoding, _  := asn1.Marshal(r) 
        fmt.Printf("% X\n", encoding)

        var t *big.Int  // <---- changed type
        _, err := asn1.Unmarshal(encoding, &t)
        if err != nil {
            fmt.Println("Erreur unmarshalling -", err)
        }   

        fmt.Println(t.String())
}

产量：

paul@horus:asn1int$ ./asn1int
02 0E 48 1B 6A 09 13 BD 80 24 CA 5D 22 F0 14 F3
1462505468235399478280266926003443
paul@horus:asn1int$

为什么在 Golang 中将 DER ASN.1 大整数的解组限制为 SEQUENCE？

Why is unmarshalling of a DER ASN.1 large integer limited to SEQUENCE in Golang?

go

asn.1