cactus-cli: fix entry type decode and pretty-print tbs_cert_entry

entryShow read the MerkleTreeCertEntry type from the first two bytes, but
those are the extensions<0..2^16-1> length prefix (always 0x0000 since
cactus emits an empty extensions vector). The type lives *after* the
extensions vector, so every entry decoded as type 0 and printed as
null_entry. Skip the extensions vector before reading the uint16 type.

Add cert.ParseTBSCertificateLogEntry (the inverse of MarshalContents) and
use it to pretty-print the decoded fields — version, issuer/subject DN,
validity, SPKI algorithm and hash, and extensions (including SAN dNSNames)
— instead of a raw hex preview.

Author: mcpherrinm

cert/entry.go

@@ -2,6 +2,7 @@ package cert
 
 import (
 	"crypto/sha256"
+	"encoding/asn1"
 	"errors"
 	"fmt"
 	"hash"
@@ -233,6 +234,109 @@ func (e *TBSCertificateLogEntry) MarshalDER() ([]byte, error) {
 	return wrapSequence(b.Bytes()), nil
 }
 
+// ParseTBSCertificateLogEntry is the inverse of MarshalContents: it
+// decodes the contents octets of a TBSCertificateLogEntry (i.e.
+// MerkleTreeCertEntry.tbs_cert_entry_data, without the outer SEQUENCE
+// header) into the structured fields. The DER-valued fields (IssuerDN,
+// SubjectDN, SubjectPublicKeyAlgorithm, Extensions) are returned as their
+// raw DER, exactly as MarshalDER would emit them, so round-tripping is
+// lossless.
+func ParseTBSCertificateLogEntry(contents []byte) (*TBSCertificateLogEntry, error) {
+	e := &TBSCertificateLogEntry{}
+	rest := contents
+
+	read := func(field string) (asn1.RawValue, error) {
+		var rv asn1.RawValue
+		var err error
+		rest, err = asn1.Unmarshal(rest, &rv)
+		if err != nil {
+			return rv, fmt.Errorf("parse %s: %w", field, err)
+		}
+		return rv, nil
+	}
+
+	// version [0] EXPLICIT Version DEFAULT v1 — present only when != v1.
+	rv, err := read("version/issuer")
+	if err != nil {
+		return nil, err
+	}
+	if rv.Class == asn1.ClassContextSpecific && rv.Tag == 0 {
+		var v int
+		if _, err := asn1.Unmarshal(rv.Bytes, &v); err != nil {
+			return nil, fmt.Errorf("parse version: %w", err)
+		}
+		e.Version = v
+		if rv, err = read("issuer"); err != nil {
+			return nil, err
+		}
+	}
+
+	// issuer Name (the RawValue currently in rv).
+	e.IssuerDN = rv.FullBytes
+
+	// validity SEQUENCE { notBefore Time, notAfter Time }.
+	validity, err := read("validity")
+	if err != nil {
+		return nil, err
+	}
+	vrest := validity.Bytes
+	for i, dst := range []*time.Time{&e.NotBefore, &e.NotAfter} {
+		var t time.Time
+		vrest, err = asn1.Unmarshal(vrest, &t)
+		if err != nil {
+			return nil, fmt.Errorf("parse validity[%d]: %w", i, err)
+		}
+		*dst = t
+	}
+
+	// subject Name.
+	subject, err := read("subject")
+	if err != nil {
+		return nil, err
+	}
+	e.SubjectDN = subject.FullBytes
+
+	// subjectPublicKeyAlgorithm AlgorithmIdentifier.
+	alg, err := read("subjectPublicKeyAlgorithm")
+	if err != nil {
+		return nil, err
+	}
+	e.SubjectPublicKeyAlgorithm = alg.FullBytes
+
+	// subjectPublicKeyInfoHash OCTET STRING.
+	spkiHash, err := read("subjectPublicKeyInfoHash")
+	if err != nil {
+		return nil, err
+	}
+	if spkiHash.Tag != asn1.TagOctetString || spkiHash.Class != asn1.ClassUniversal {
+		return nil, fmt.Errorf("subjectPublicKeyInfoHash: unexpected tag 0x%02x", spkiHash.FullBytes[0])
+	}
+	e.SubjectPublicKeyInfoHash = spkiHash.Bytes
+
+	// Optional tail: issuerUniqueID [1], subjectUniqueID [2], extensions [3].
+	for len(rest) > 0 {
+		rv, err := read("tail field")
+		if err != nil {
+			return nil, err
+		}
+		if rv.Class != asn1.ClassContextSpecific {
+			return nil, fmt.Errorf("unexpected entry field class=%d tag=%d", rv.Class, rv.Tag)
+		}
+		switch rv.Tag {
+		case 1:
+			e.IssuerUniqueID = rv.Bytes
+		case 2:
+			e.SubjectUniqueID = rv.Bytes
+		case 3:
+			// extensions [3] EXPLICIT — rv.Bytes is the Extensions SEQUENCE DER.
+			e.Extensions = rv.Bytes
+		default:
+			return nil, fmt.Errorf("unknown entry context-specific tag %d", rv.Tag)
+		}
+	}
+	return e, nil
+}
+
 // EntryHash implements the §7.2 single-pass hash for a tbs_cert_entry
 // with an empty extensions vector (the only form cactus emits):
 //

cert/entry_test.go

@@ -116,6 +116,79 @@ func TestMarshalDERIsParseable(t *testing.T) {
 	}
 }
 
+func TestParseTBSCertificateLogEntryRoundTrip(t *testing.T) {
+	dn, err := BuildCAName("32473.1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	subjectDN, err := BuildCAName("cactus.test/example")
+	if err != nil {
+		t.Fatal(err)
+	}
+	algID := []byte{
+		0x30, 0x13,
+		0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01,
+		0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07,
+	}
+	// A minimal Extensions SEQUENCE with one extension.
+	exts := []byte{
+		0x30, 0x09,
+		0x30, 0x07,
+		0x06, 0x03, 0x55, 0x1d, 0x0f, // OID 2.5.29.15 (keyUsage)
+		0x04, 0x00, // empty OCTET STRING value
+	}
+
+	for _, tc := range []struct {
+		name string
+		e    *TBSCertificateLogEntry
+	}{
+		{"minimal", &TBSCertificateLogEntry{
+			Version:                   2,
+			IssuerDN:                  dn,
+			NotBefore:                 time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
+			NotAfter:                  time.Date(2026, 5, 8, 0, 0, 0, 0, time.UTC),
+			SubjectDN:                 subjectDN,
+			SubjectPublicKeyAlgorithm: algID,
+			SubjectPublicKeyInfoHash:  bytes.Repeat([]byte{0xab}, 32),
+		}},
+		{"v1-with-extensions", &TBSCertificateLogEntry{
+			Version:                   0, // v1: version field omitted
+			IssuerDN:                  dn,
+			NotBefore:                 time.Date(2051, 1, 2, 3, 4, 5, 0, time.UTC), // GeneralizedTime path
+			NotAfter:                  time.Date(2052, 6, 7, 8, 9, 10, 0, time.UTC),
+			SubjectDN:                 subjectDN,
+			SubjectPublicKeyAlgorithm: algID,
+			SubjectPublicKeyInfoHash:  bytes.Repeat([]byte{0xcd}, 32),
+			Extensions:                exts,
+		}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			contents, err := tc.e.MarshalContents()
+			if err != nil {
+				t.Fatal(err)
+			}
+			got, err := ParseTBSCertificateLogEntry(contents)
+			if err != nil {
+				t.Fatalf("ParseTBSCertificateLogEntry: %v", err)
+			}
+			// Re-marshalling the parsed entry must reproduce the input.
+			reMarshalled, err := got.MarshalContents()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(reMarshalled, contents) {
+				t.Errorf("round-trip mismatch:\n got %x\nwant %x", reMarshalled, contents)
+			}
+			if got.Version != tc.e.Version {
+				t.Errorf("Version = %d, want %d", got.Version, tc.e.Version)
+			}
+			if !got.NotBefore.Equal(tc.e.NotBefore) || !got.NotAfter.Equal(tc.e.NotAfter) {
+				t.Errorf("validity = %s..%s, want %s..%s", got.NotBefore, got.NotAfter, tc.e.NotBefore, tc.e.NotAfter)
+			}
+		})
+	}
+}
+
 func TestRoundTripDERLength(t *testing.T) {
 	cases := []int{0, 1, 0x7f, 0x80, 0xff, 0x100, 0xffff, 0x10000}
 	for _, n := range cases {

cmd/cactus-cli/main.go

@@ -9,6 +9,8 @@ package main
 
 import (
 	"crypto/sha256"
+	"crypto/x509/pkix"
+	"encoding/asn1"
 	"encoding/base64"
 	"encoding/pem"
 	"errors"
@@ -113,19 +115,175 @@ func entryShow(logURL string, idx uint64) {
 	if err != nil {
 		die("fetch entry: %v", err)
 	}
+	// MerkleTreeCertEntry (§5.2.1): extensions<0..2^16-1> then uint16 type
+	// then the type-specific data. The leading uint16 is the extensions
+	// vector length, NOT the type.
 	if len(body) < 2 {
 		die("entry too short")
 	}
-	t := uint16(body[0])<<8 | uint16(body[1])
+	extLen := int(body[0])<<8 | int(body[1])
+	if len(body) < 2+extLen+2 {
+		die("entry too short (ext_len=%d, %d bytes)", extLen, len(body))
+	}
+	rest := body[2+extLen:]
+	t := uint16(rest[0])<<8 | uint16(rest[1])
+	data := rest[2:]
 	switch t {
 	case 0:
 		fmt.Printf("entry %d: null_entry\n", idx)
 	case 1:
-		fmt.Printf("entry %d: tbs_cert_entry, %d bytes\n", idx, len(body)-2)
-		fmt.Printf("  raw (first 64 bytes): %x\n", body[2:min(len(body), 66)])
+		fmt.Printf("entry %d: tbs_cert_entry, %d bytes\n", idx, len(data))
+		e, err := cert.ParseTBSCertificateLogEntry(data)
+		if err != nil {
+			fmt.Printf("  (decode failed: %v)\n", err)
+			fmt.Printf("  raw (first 64 bytes): %x\n", data[:min(len(data), 64)])
+			break
+		}
+		printLogEntry(e)
 	default:
-		fmt.Printf("entry %d: unknown type %d, %d bytes\n", idx, t, len(body))
+		fmt.Printf("entry %d: unknown type %d, %d bytes\n", idx, t, len(data))
+	}
+}
+
+// printLogEntry pretty-prints the decoded fields of a TBSCertificateLogEntry.
+func printLogEntry(e *cert.TBSCertificateLogEntry) {
+	fmt.Printf("  version:    v%d\n", e.Version+1)
+	fmt.Printf("  issuer:     %s\n", formatDN(e.IssuerDN))
+	fmt.Printf("  not before: %s\n", e.NotBefore.UTC().Format("2006-01-02T15:04:05Z"))
+	fmt.Printf("  not after:  %s\n", e.NotAfter.UTC().Format("2006-01-02T15:04:05Z"))
+	fmt.Printf("  subject:    %s\n", formatDN(e.SubjectDN))
+	fmt.Printf("  spki alg:   %s\n", formatAlgID(e.SubjectPublicKeyAlgorithm))
+	fmt.Printf("  spki hash:  %x (sha-256)\n", e.SubjectPublicKeyInfoHash)
+	if e.IssuerUniqueID != nil {
+		fmt.Printf("  issuerUID:  %x\n", e.IssuerUniqueID)
+	}
+	if e.SubjectUniqueID != nil {
+		fmt.Printf("  subjectUID: %x\n", e.SubjectUniqueID)
+	}
+	if e.Extensions != nil {
+		fmt.Printf("  extensions:\n")
+		for _, line := range formatExtensions(e.Extensions) {
+			fmt.Printf("    %s\n", line)
+		}
+	}
+}
+
+// attrNames maps the AttributeType OIDs cactus may emit in a Name to
+// short labels. Unknown OIDs fall back to dotted notation.
+var attrNames = map[string]string{
+	cert.OIDRDNATrustAnchorID.String(): "trustAnchorID",
+	"2.5.4.3":                          "CN",
+	"2.5.4.6":                          "C",
+	"2.5.4.10":                         "O",
+	"2.5.4.11":                         "OU",
+}
+
+// formatDN renders a DER-encoded Name (RDNSequence) as "type=value, …".
+func formatDN(der []byte) string {
+	if len(der) == 0 {
+		return "(empty)"
+	}
+	var rdns pkix.RDNSequence
+	if _, err := asn1.Unmarshal(der, &rdns); err != nil {
+		return fmt.Sprintf("<unparseable: %x>", der)
+	}
+	if len(rdns) == 0 {
+		return "(empty)"
+	}
+	var parts []string
+	for _, rdn := range rdns {
+		for _, atv := range rdn {
+			name := atv.Type.String()
+			if n, ok := attrNames[name]; ok {
+				name = n
+			}
+			parts = append(parts, fmt.Sprintf("%s=%v", name, atv.Value))
+		}
+	}
+	return strings.Join(parts, ", ")
+}
+
+// formatAlgID renders an AlgorithmIdentifier as its OID (named if known).
+func formatAlgID(der []byte) string {
+	var alg struct {
+		Algorithm  asn1.ObjectIdentifier
+		Parameters asn1.RawValue `asn1:"optional"`
+	}
+	if _, err := asn1.Unmarshal(der, &alg); err != nil {
+		return fmt.Sprintf("<unparseable: %x>", der)
+	}
+	oid := alg.Algorithm.String()
+	if name, ok := algNames[oid]; ok {
+		return fmt.Sprintf("%s (%s)", name, oid)
+	}
+	return oid
+}
+
+// algNames maps SPKI algorithm OIDs to friendly names.
+var algNames = map[string]string{
+	"2.16.840.1.101.3.4.3.17": "ML-DSA-44",
+	"1.2.840.10045.2.1":       "ecPublicKey",
+	"1.2.840.113549.1.1.1":    "rsaEncryption",
+}
+
+// extOIDNames maps certificate extension OIDs to short labels.
+var extOIDNames = map[string]string{
+	"2.5.29.15": "keyUsage",
+	"2.5.29.17": "subjectAltName",
+	"2.5.29.19": "basicConstraints",
+	"2.5.29.37": "extKeyUsage",
+}
+
+// formatExtensions decodes a DER Extensions SEQUENCE into one display
+// line per extension.
+func formatExtensions(der []byte) []string {
+	var exts []pkix.Extension
+	if _, err := asn1.Unmarshal(der, &exts); err != nil {
+		return []string{fmt.Sprintf("<unparseable: %x>", der)}
+	}
+	var lines []string
+	for _, ext := range exts {
+		oid := ext.Id.String()
+		name := extOIDNames[oid]
+		label := oid
+		if name != "" {
+			label = fmt.Sprintf("%s %s", oid, name)
+		}
+		if ext.Critical {
+			label += " (critical)"
+		}
+		if name == "subjectAltName" {
+			if sans := formatSAN(ext.Value); sans != "" {
+				label += "  " + sans
+			}
+		}
+		lines = append(lines, label)
+	}
+	return lines
+}
+
+// formatSAN extracts the dNSName entries from a SubjectAltName extension
+// value (the GeneralNames SEQUENCE), the common case for cactus leaves.
+func formatSAN(der []byte) string {
+	var seq asn1.RawValue
+	if _, err := asn1.Unmarshal(der, &seq); err != nil {
+		return ""
+	}
+	var names []string
+	rest := seq.Bytes
+	for len(rest) > 0 {
+		var gn asn1.RawValue
+		var err error
+		rest, err = asn1.Unmarshal(rest, &gn)
+		if err != nil {
+			break
+		}
+		// dNSName is [2] IMPLICIT IA5String.
+		if gn.Class == asn1.ClassContextSpecific && gn.Tag == 2 {
+			names = append(names, "DNS:"+string(gn.Bytes))
+		}
 	}
+	return strings.Join(names, ", ")
 }
 
 // certVerify performs the §7.2 verification: decode MTCProof, recompute