remove redundant per-publisher trust anchor (catalogue is the source of truth)

The release-signed catalogue pins each bundle's sha256, and pilotctl verifies
that pin at install — so a non-sideloaded app is, by construction, vouched for
by the catalogue signature (the root of trust). The separate per-publisher
TrustedPublishers allow-list (added in #7, enforced in #23) is redundant with
that, and unworkable in practice: apps are self-signed with per-app keys, the
publishers registry isn't populated, and the metadata publisher_pubkeys are
placeholders/mismatched — so enforcement skipped EVERY catalogue app unless an
env var was set on each host.

Removed:
- manifest.TrustedPublishers + Manifest.VerifyTrustAnchor (+ their unit tests)
- the supervisor's VerifyTrustAnchor enforcement on the catalogue path
  (VerifySignature still confirms manifest integrity)

The catalogue path now: install-time sha pin (signed catalogue) + VerifySignature.
Sideloaded apps remain clamped to the safe grant subset.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Alex Godoroja

pkg/manifest/manifest.go

@@ -9,7 +9,6 @@
 package manifest
 
 import (
-	"bytes"
 	"crypto/ed25519"
 	"crypto/sha256"
 	"encoding/base64"
@@ -180,9 +179,7 @@ func canonicalJSON(v any) ([]byte, error) {
 // signingPayload builds the canonical byte-string the Store.Signature
 // must sign. The publisher key is included so that a signature cannot
 // be reused with a different publisher identity — swapping the
-// publisher key invalidates the signature. Once a trust-anchor check
-// (hardcoded publisher pubkey match) is added, this guarantees the
-// manifest was signed by the known publisher.
+// publisher key invalidates the signature.
 //
 // Format: publisher || ":" || id || ":" || manifest_version || ":" || binary.sha256 || ":" || grants-sha256-hex
 func (m *Manifest) signingPayload() ([]byte, error) {
@@ -196,61 +193,17 @@ func (m *Manifest) signingPayload() ([]byte, error) {
 	return []byte(payload), nil
 }
 
-// TrustedPublishers is the compile-time-embedded list of publisher
-// ed25519 public keys ("ed25519:<base64>" or raw base64) that are
-// trusted to sign manifests. Empty list = fail-closed (no publisher
-// passes the trust-anchor check). Production builds MUST populate
-// this list with the known-good publisher keys.
-var TrustedPublishers []string
-
-// VerifyTrustAnchor checks that Store.Publisher is on the trusted
-// publishers list. Without this check, VerifySignature only confirms
-// the manifest was signed by whoever claims to be the publisher;
-// VerifyTrustAnchor confirms the publisher itself is known and trusted.
-//
-// Returns nil if Store.Publisher is in TrustedPublishers.
-// Returns an error if TrustedPublishers is empty (fail-closed) or if
-// the publisher is not found.
-func (m *Manifest) VerifyTrustAnchor() error {
-	if len(TrustedPublishers) == 0 {
-		return fmt.Errorf("trust anchor: TrustedPublishers is empty — no publisher is trusted")
-	}
-
-	pubkeyRaw, ok := strings.CutPrefix(m.Store.Publisher, "ed25519:")
-	if !ok {
-		return fmt.Errorf("store.publisher must be \"ed25519:<base64>\"")
-	}
-	pubkey, err := base64.StdEncoding.DecodeString(pubkeyRaw)
-	if err != nil {
-		return fmt.Errorf("store.publisher: invalid base64: %w", err)
-	}
-	if len(pubkey) != ed25519.PublicKeySize {
-		return fmt.Errorf("store.publisher: wrong key length %d, want %d", len(pubkey), ed25519.PublicKeySize)
-	}
-
-	for _, trusted := range TrustedPublishers {
-		trustedRaw := strings.TrimPrefix(trusted, "ed25519:")
-		trustedKey, err := base64.StdEncoding.DecodeString(trustedRaw)
-		if err != nil {
-			continue // skip malformed entries
-		}
-		if bytes.Equal(pubkey, trustedKey) {
-			return nil
-		}
-	}
-	return fmt.Errorf("trust anchor: publisher %s is not on the trusted-publishers list", m.Store.Publisher)
-}
-
 // VerifySignature checks that Store.Signature is a valid ed25519
 // signature over the signing payload, verified against the Store.Publisher
 // key embedded in the manifest. This provides cryptographic integrity —
 // tampering with any manifest field that feeds the signing payload
 // (Publisher, ID, ManifestVersion, Binary.SHA256, Grants) will cause
 // verification to fail.
 //
-// IMPORTANT: This does NOT check that Store.Publisher is a trusted key.
-// Callers MUST also call VerifyTrustAnchor() after VerifySignature()
-// to confirm the publisher is on the TrustedPublishers list.
+// For catalogue installs, trust comes from the release-signed catalogue,
+// which pins each bundle's sha256 (verified by pilotctl at install time);
+// VerifySignature here confirms the manifest itself was not altered after
+// the publisher signed it. There is no separate per-publisher trust anchor.
 func (m *Manifest) VerifySignature() error {
 	pubkeyRaw, ok := strings.CutPrefix(m.Store.Publisher, "ed25519:")
 	if !ok {

pkg/manifest/manifest_test.go

@@ -61,10 +61,10 @@ func TestValidWalletManifest(t *testing.T) {
 
 func TestRejectsBadID(t *testing.T) {
 	cases := map[string]string{
-		"empty":         "",
-		"no_dot":        "wallet",
-		"uppercase":     "io.Pilot.Wallet",
-		"trailing_dot":  "io.pilot.wallet.",
+		"empty":        "",
+		"no_dot":       "wallet",
+		"uppercase":    "io.Pilot.Wallet",
+		"trailing_dot": "io.pilot.wallet.",
 	}
 	for name, badID := range cases {
 		t.Run(name, func(t *testing.T) {
@@ -390,112 +390,6 @@ func TestVerifySignatureRejectsEmptySignature(t *testing.T) {
 	}
 }
 
-func TestVerifyTrustAnchorEmptyListIsFailClosed(t *testing.T) {
-	// With TrustedPublishers empty (default), VerifyTrustAnchor must reject all publishers.
-	orig := TrustedPublishers
-	TrustedPublishers = nil
-	defer func() { TrustedPublishers = orig }()
-
-	m := mustValid(t)
-	if err := m.VerifyTrustAnchor(); err == nil {
-		t.Error("expected error with empty TrustedPublishers, got nil")
-	}
-}
-
-func TestVerifyTrustAnchorRejectsUntrustedPublisher(t *testing.T) {
-	trustedPub, _, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-	untrustedPub, _, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	orig := TrustedPublishers
-	TrustedPublishers = []string{"ed25519:" + base64Enc(trustedPub)}
-	defer func() { TrustedPublishers = orig }()
-
-	m := mustValid(t)
-	m.Store.Publisher = "ed25519:" + base64Enc(untrustedPub)
-	if err := m.VerifyTrustAnchor(); err == nil {
-		t.Error("expected error for untrusted publisher, got nil")
-	}
-}
-
-func TestVerifyTrustAnchorAcceptsTrustedPublisher(t *testing.T) {
-	pub, priv, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	orig := TrustedPublishers
-	TrustedPublishers = []string{"ed25519:" + base64Enc(pub)}
-	defer func() { TrustedPublishers = orig }()
-
-	m := mustValid(t)
-	m.Store.Publisher = "ed25519:" + base64Enc(pub)
-	sig, err := signTestManifest(m, priv)
-	if err != nil {
-		t.Fatal(err)
-	}
-	m.Store.Signature = sig
-
-	// VerifySignature must pass for a valid signature.
-	if err := m.VerifySignature(); err != nil {
-		t.Fatalf("valid signature rejected: %v", err)
-	}
-	// VerifyTrustAnchor must pass because the publisher IS trusted.
-	if err := m.VerifyTrustAnchor(); err != nil {
-		t.Errorf("trusted publisher rejected by VerifyTrustAnchor: %v", err)
-	}
-}
-
-func TestVerifyTrustAnchorMultipleTrustedKeys(t *testing.T) {
-	pub1, _, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-	pub2, priv2, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	orig := TrustedPublishers
-	TrustedPublishers = []string{
-		"ed25519:" + base64Enc(pub1),
-		"ed25519:" + base64Enc(pub2),
-	}
-	defer func() { TrustedPublishers = orig }()
-
-	m := mustValid(t)
-	m.Store.Publisher = "ed25519:" + base64Enc(pub2)
-	sig, err := signTestManifest(m, priv2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	m.Store.Signature = sig
-
-	if err := m.VerifySignature(); err != nil {
-		t.Fatalf("valid signature rejected: %v", err)
-	}
-	if err := m.VerifyTrustAnchor(); err != nil {
-		t.Errorf("second trusted publisher rejected: %v", err)
-	}
-}
-
-func TestVerifyTrustAnchorRejectsBadPublisherFormat(t *testing.T) {
-	orig := TrustedPublishers
-	TrustedPublishers = []string{"ed25519:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="}
-	defer func() { TrustedPublishers = orig }()
-
-	m := mustValid(t)
-	m.Store.Publisher = "not-valid-publisher"
-	if err := m.VerifyTrustAnchor(); err == nil {
-		t.Error("expected error with bad publisher format, got nil")
-	}
-}
-
 func hasErrorContaining(errs []error, substr string) bool {
 	for _, e := range errs {
 		if strings.Contains(e.Error(), substr) {

plugin/appstore/supervisor.go

@@ -58,14 +58,14 @@ const maxAuditLogSize = 10 * 1024 * 1024
 // auditEvent is one line in the supervisor.log JSONL stream.
 // AppID + EventType + At are always populated; the rest depends on type.
 type auditEvent struct {
-	At        time.Time `json:"at"`
-	AppID     string    `json:"app"`
-	Event     string    `json:"event"` // "spawn", "exit", "suspend", "verify-fail"
-	PID       int       `json:"pid,omitempty"`
-	ExitCode  int       `json:"exit_code,omitempty"`
-	Reason    string    `json:"reason,omitempty"`
-	SHA256    string    `json:"sha256,omitempty"`     // pinned hash, recorded on spawn for traceability
-	BinaryAt  string    `json:"binary_path,omitempty"`
+	At       time.Time `json:"at"`
+	AppID    string    `json:"app"`
+	Event    string    `json:"event"` // "spawn", "exit", "suspend", "verify-fail"
+	PID      int       `json:"pid,omitempty"`
+	ExitCode int       `json:"exit_code,omitempty"`
+	Reason   string    `json:"reason,omitempty"`
+	SHA256   string    `json:"sha256,omitempty"` // pinned hash, recorded on spawn for traceability
+	BinaryAt string    `json:"binary_path,omitempty"`
 }
 
 // writeAuditLine appends one JSON-encoded event to the app's
@@ -164,9 +164,9 @@ type supervisor struct {
 
 	// mu guards installed + ready + crashes + appCancel.
 	mu        sync.RWMutex
-	installed map[string]*installedApp    // app_id → record
-	ready     map[string]bool             // app_id → socket has appeared at least once
-	crashes   map[string]*crashRecord     // app_id → sliding-window crash counter
+	installed map[string]*installedApp      // app_id → record
+	ready     map[string]bool               // app_id → socket has appeared at least once
+	crashes   map[string]*crashRecord       // app_id → sliding-window crash counter
 	appCancel map[string]context.CancelFunc // app_id → cancel its per-app context (used to stop a supervise goroutine on detected uninstall)
 }
 
@@ -335,22 +335,21 @@ func (s *supervisor) scanInstalled() ([]*installedApp, error) {
 				continue
 			}
 		} else {
-			// Catalogue path: a non-sideloaded install must satisfy the
-			// FULL trust chain, not just signature integrity.
-			// VerifySignature alone only proves the manifest was signed
-			// by whoever claims to be the publisher — a self-signed
-			// manifest from an UNTRUSTED key passes it. VerifyTrustAnchor
-			// then confirms that publisher key is on the trusted list.
-			// Both are required; sideloading (above) is the explicit,
-			// local opt-out of this chain.
+			// Catalogue path: trust comes from the RELEASE-SIGNED CATALOGUE,
+			// which pins each bundle's sha256. `pilotctl install` verifies that
+			// pin against the signed catalogue before extracting, so a
+			// non-sideloaded app is — by construction — vouched for by the
+			// catalogue signature (the root of trust). VerifySignature here
+			// additionally confirms manifest integrity (the binary sha + grants
+			// were not altered after the publisher signed). A separate
+			// per-publisher allow-list is redundant with the catalogue anchor
+			// (and unworkable: apps are self-signed with per-app keys), so it is
+			// intentionally not enforced. Sideloading (above) is the explicit
+			// local opt-out, clamped to the safe grant subset.
 			if err := m.VerifySignature(); err != nil {
 				s.logger.Printf("skip %s: signature verification failed: %v", e.Name(), err)
 				continue
 			}
-			if err := m.VerifyTrustAnchor(); err != nil {
-				s.logger.Printf("skip %s: publisher not trusted: %v", e.Name(), err)
-				continue
-			}
 		}
 		// Reject path traversal in manifest.binary.path. Without this
 		// a manifest containing binary.path="../../../bin/sh" (or any

plugin/appstore/testhelpers_test.go

@@ -25,12 +25,8 @@ func newQuietLogger(t *testing.T) *log.Logger {
 }
 
 // testPublisherSeed is a fixed Ed25519 seed so every helper-built
-// manifest is signed by the SAME publisher key. TestMain pins that key
-// into manifest.TrustedPublishers exactly once, before any test runs,
-// so the catalogue (non-sideloaded) trust-anchor check passes for
-// helper-built apps. Using a fixed key (set once, never mutated during
-// the run) keeps this race-free under `go test -race`, where supervisor
-// goroutines read TrustedPublishers concurrently.
+// manifest is signed by the SAME publisher key — keeping signatures
+// deterministic across the suite.
 var testPublisherSeed = [ed25519.SeedSize]byte{
 	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
 	17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
@@ -41,15 +37,6 @@ func testPublisherKey() (ed25519.PublicKey, ed25519.PrivateKey) {
 	return priv.Public().(ed25519.PublicKey), priv
 }
 
-// TestMain pins the fixed test publisher as the sole trust anchor for
-// the whole package, then runs the suite. Set once, before any goroutine
-// reads it — no mutation during the run, so no data race.
-func TestMain(m *testing.M) {
-	pub, _ := testPublisherKey()
-	manifest.TrustedPublishers = []string{"ed25519:" + base64.StdEncoding.EncodeToString(pub)}
-	os.Exit(m.Run())
-}
-
 // parseDummyManifest returns a minimal *manifest.Manifest with the
 // given id. Used by tests that need a manifest struct without going
 // through the disk layout. The values are intentionally minimal — the
@@ -66,13 +53,12 @@ func parseDummyManifest(t *testing.T, id string) *manifest.Manifest {
 }
 
 // writeValidAppDir creates <root>/<id>/manifest.json with a manifest
-// that passes manifest.Parse + Validate + VerifySignature AND
-// VerifyTrustAnchor (so scanInstalled accepts it on the catalogue path).
-// It signs with the fixed test publisher key that TestMain pins into
-// manifest.TrustedPublishers. No binary is written — the supervisor
-// will hit verify-fail when it tries to spawn, but for tests that only
-// care about discovery / registration (rescan, Apps()) that's the
-// desired behavior.
+// that passes manifest.Parse + Validate + VerifySignature (so
+// scanInstalled accepts it on the catalogue path). It signs with the
+// fixed test publisher key. No binary is written — the supervisor will
+// hit verify-fail when it tries to spawn, but for tests that only care
+// about discovery / registration (rescan, Apps()) that's the desired
+// behavior.
 func writeValidAppDir(t *testing.T, root, id string) string {
 	t.Helper()
 	dir := filepath.Join(root, id)
@@ -123,12 +109,10 @@ func writeValidAppDir(t *testing.T, root, id string) string {
 }
 
 // writeUntrustedSignedAppDir creates <root>/<id>/manifest.json with a
-// manifest that carries a VALID self-signature from a FRESH (untrusted)
-// publisher key — i.e. it passes VerifySignature but NOT VerifyTrustAnchor.
-// No `.sideloaded` marker is planted. This is the trust-boundary case:
-// a catalogue install must be refused unless the publisher is on the
-// trusted-publishers list, even when the signature itself is internally
-// consistent.
+// manifest that carries a VALID self-signature from a FRESH publisher key
+// (i.e. it passes VerifySignature), with no `.sideloaded` marker. Trust
+// for the catalogue path is the release-signed catalogue, not the
+// publisher key, so such an app is accepted on scan.
 func writeUntrustedSignedAppDir(t *testing.T, root, id string) string {
 	t.Helper()
 	dir := filepath.Join(root, id)

plugin/appstore/zz_sideload_scan_test.go

@@ -125,26 +125,24 @@ func TestScanInstalled_UnsignedWithoutMarkerStillRejected(t *testing.T) {
 	}
 }
 
-// TestScanInstalled_UntrustedPublisherWithoutMarkerRejected is the
-// trust-boundary regression: a manifest whose signature VERIFIES but
-// whose publisher is NOT on the trusted-publishers list, with no
-// `.sideloaded` marker, must be refused. Signature validity alone is
-// not trust — a non-sideloaded (catalogue) install must satisfy the
-// full trust-anchor check. Before the fix, scanInstalled ran only
-// VerifySignature on the catalogue path, so a self-signed-by-anyone
-// manifest was silently accepted and spawned.
-func TestScanInstalled_UntrustedPublisherWithoutMarkerRejected(t *testing.T) {
+// TestScanInstalled_CatalogueAppWithoutMarkerAccepted: a non-sideloaded app with
+// a valid self-signature is accepted on the catalogue path. Trust is the
+// release-signed catalogue (pilotctl pins each bundle's sha256 at install); the
+// supervisor confirms manifest integrity via VerifySignature. There is no
+// separate per-publisher allow-list (it was redundant with the catalogue anchor
+// and unworkable with per-app publisher keys).
+func TestScanInstalled_CatalogueAppWithoutMarkerAccepted(t *testing.T) {
 	t.Parallel()
 	root := t.TempDir()
-	// Valid self-signature, fresh untrusted key, NO .sideloaded marker.
-	writeUntrustedSignedAppDir(t, root, "io.untrusted.app")
+	// Valid self-signature, fresh publisher key, NO .sideloaded marker.
+	writeUntrustedSignedAppDir(t, root, "io.catalogue.app")
 
 	sup := newSupervisor(Config{InstallRoot: root}, Deps{}, newQuietLogger(t))
 	apps, err := sup.scanInstalled()
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(apps) != 0 {
-		t.Fatalf("apps = %d, want 0 (validly-signed but UNTRUSTED publisher must be refused on the catalogue path)", len(apps))
+	if len(apps) != 1 {
+		t.Fatalf("apps = %d, want 1 (a validly-signed catalogue app is accepted; trust is the signed catalogue, not a publisher allow-list)", len(apps))
 	}
 }