func ReadOpaqueKeyrings(r io.Reader) OpaqueKeyringChan {
c := make(OpaqueKeyringChan)
or := packet.NewOpaqueReader(r)
go func() {
defer close(c)
var op *packet.OpaquePacket
var err error
var current *OpaqueKeyring
for op, err = or.Next(); err == nil; op, err = or.Next() {
switch op.Tag {
case 6: //packet.PacketTypePublicKey:
if current != nil {
c <- current
current = nil
}
current = new(OpaqueKeyring)
fallthrough
case 13: //packet.PacketTypeUserId:
fallthrough
case 17: //packet.PacketTypeUserAttribute:
fallthrough
case 14: //packet.PacketTypePublicSubkey:
fallthrough
case 2: //packet.PacketTypeSignature:
current.Packets = append(current.Packets, op)
}
}
if err == io.EOF && current != nil {
c <- current
} else if err != nil {
c <- &OpaqueKeyring{Error: err}
}
}()
return c
}
func (pubkey *Pubkey) UnsupportedPackets() (result []*packet.OpaquePacket) {
r := packet.NewOpaqueReader(bytes.NewBuffer(pubkey.Unsupported))
for op, err := r.Next(); err == nil; op, err = r.Next() {
result = append(result, op)
}
return
}
func TestUatRtt(t *testing.T) {
f := MustInput(t, "uat.asc")
defer f.Close()
block, err := armor.Decode(f)
if err != nil {
t.Fatal(err)
}
var p packet.Packet
for {
p, err = packet.Read(block.Body)
if err != nil {
break
}
if uat, is := p.(*packet.UserAttribute); is {
var buf bytes.Buffer
uat.Serialize(&buf)
or := packet.NewOpaqueReader(bytes.NewBuffer(buf.Bytes()))
op, _ := or.Next()
assert.Equal(t, buf.Bytes()[3:], op.Contents)
}
}
}
func TestDupSig(t *testing.T) {
{
f := MustInput(t, "252B8B37.dupsig.asc")
defer f.Close()
block, err := armor.Decode(f)
if err != nil {
t.Fatal(err)
}
r := packet.NewOpaqueReader(block.Body)
var packets []*packet.OpaquePacket
for {
if op, err := r.Next(); err != nil {
break
} else {
packets = append(packets, op)
t.Log("raw:", op)
}
}
sksDigest := sksDigestOpaque(packets, md5.New())
assert.Equal(t, sksDigest, "6d57b48c83d6322076d634059bb3b94b")
}
// Read a key
{
f := MustInput(t, "252B8B37.dupsig.asc")
defer f.Close()
block, err := armor.Decode(f)
if err != nil {
t.Fatal(err)
}
var key *Pubkey
for keyRead := range readKeys(block.Body) {
assert.Nil(t, keyRead.Error)
key = keyRead.Pubkey
}
var packets []*packet.OpaquePacket
key.Visit(func(rec PacketRecord) error {
op, err := rec.GetOpaquePacket()
assert.Nil(t, err)
packets = append(packets, op)
return err
})
r := packet.NewOpaqueReader(bytes.NewBuffer(key.Unsupported))
for op, err := r.Next(); err == nil; op, err = r.Next() {
packets = append(packets, op)
}
sksDigest := sksDigestOpaque(packets, md5.New())
assert.Equal(t, sksDigest, "6d57b48c83d6322076d634059bb3b94b")
}
// Now read & resolve
key := MustInputAscKey(t, "252B8B37.dupsig.asc")
key.Visit(func(rec PacketRecord) error {
op, err := rec.GetOpaquePacket()
assert.Nil(t, err)
t.Log("parsed:", op)
return nil
})
r := packet.NewOpaqueReader(bytes.NewBuffer(key.Unsupported))
for op, err := r.Next(); err == nil; op, err = r.Next() {
t.Log("parsed:", op)
}
assert.Equal(t, key.Md5, "6d57b48c83d6322076d634059bb3b94b")
}
func toOpaquePacket(buf []byte) (*packet.OpaquePacket, error) {
r := packet.NewOpaqueReader(bytes.NewBuffer(buf))
return r.Next()
}