feat(registry): store FEE params in their own table

Review of the FIL-480 draft rejected extending blob_locations with the
per-blob FEE wrap material. blob_locations is a reconstructible cache of
the indexing-service contract — every row can be re-derived from the
indexer or the accept receipt, and the table disappears when the topology
moves to a real indexer. A wrapped CEK is not reconstructible: lose the
row and the ciphertext is unreadable forever. Key material therefore does
not belong in the one table whose design allows it to be rebuilt, or
truncated (the live test already does).

blob_encryption_params holds it instead, with no foreign key to
blob_locations: the two have independent lifecycles, and an FK would
force location-before-params write ordering. Because nothing cascades,
DeleteLocation no longer shreds — a caller removing a blob must delete
from both tables.

Two fixes to the material itself, both raised in review:

- Add header_len. The stored blob is envelope||ciphertext and nothing
  recorded where the envelope ends, so a read could not locate byte 0 of
  the ciphertext without decoding the header, leaving the "no
  header round-trip" goal out of reach.
- Store the whole COSE Enc_structure as aad instead of the protected
  header. The structure's context string differs between a COSE_Encrypt
  and a COSE_Encrypt0, which a bare row cannot record, so the protected
  header alone is not enough to rebuild the AAD. The header stays
  recoverable from the Enc_structure as element 1.

Every column is NOT NULL, so the all-or-nothing invariant is structural
rather than a nullable-column check: the existence of a row is what marks
a blob as encrypted. BlobEncryptionParams.Validate rejects an incomplete
set before SQL, replacing ValidateFEE/ErrPartialFEE.

Migration 00013 is reshaped in place — it has not shipped anywhere.

Assisted-by: Claude:claude-fable-5
Signed-off-by: Miroslav Bajtoš <oss@bajtos.net>

Author: bajtos

inmem/store.go

@@ -59,15 +59,17 @@ type MemStore struct {
 	blobRefs   map[claimKey]registry.BlobClaim
 	intents    map[string]registry.UploadIntent          // keyed by string(digest)
 	locations  map[locKey]registry.BlobLocation          // keyed by (space, digest)
+	encParams  map[locKey]registry.BlobEncryptionParams  // keyed by (space, digest)
 	inclusions map[locKey]registry.BlobInclusion         // keyed by (space, digest)
 	parks      map[string]registry.BlobPark              // keyed by string(digest)
 	sessions   map[string]registry.MultipartSession      // keyed by uploadID
 	parts      map[string]map[int]registry.MultipartPart // uploadID -> partNumber -> part
 	gcCands    map[string]struct{}                       // keyed by string(cid)
 }
 
-// claimKey / locKey are the composite map keys for the blob_refs and
-// blob_locations tables (digest bytes carried as a string for comparability).
+// claimKey / locKey are the composite map keys for the blob_refs and the
+// (space, digest)-keyed tables — blob_locations, blob_encryption_params and
+// shard_inclusions (digest bytes carried as a string for comparability).
 type claimKey struct {
 	digest, bucket, objectKey, versionID string
 }
@@ -86,6 +88,7 @@ func NewMemStore() *MemStore {
 		blobRefs:   map[claimKey]registry.BlobClaim{},
 		intents:    map[string]registry.UploadIntent{},
 		locations:  map[locKey]registry.BlobLocation{},
+		encParams:  map[locKey]registry.BlobEncryptionParams{},
 		inclusions: map[locKey]registry.BlobInclusion{},
 		parks:      map[string]registry.BlobPark{},
 		sessions:   map[string]registry.MultipartSession{},

inmem/stores.go

@@ -11,18 +11,19 @@ import (
 )
 
 // In-memory implementations of the architecture's relational stores
-// (registry.BlobRefStore / IntentStore / LocationStore / MultipartStore /
-// GCStore), mirroring the Postgres tables so the in-process suite and
-// standalone mode exercise the same write/read/delete code paths.
+// (registry.BlobRefStore / IntentStore / LocationStore / EncryptionParamsStore /
+// MultipartStore / GCStore), mirroring the Postgres tables so the in-process
+// suite and standalone mode exercise the same write/read/delete code paths.
 
 // Compile-time assertions: *MemStore satisfies every store interface.
 var (
-	_ registry.BlobRefStore   = (*MemStore)(nil)
-	_ registry.IntentStore    = (*MemStore)(nil)
-	_ registry.LocationStore  = (*MemStore)(nil)
-	_ registry.InclusionStore = (*MemStore)(nil)
-	_ registry.MultipartStore = (*MemStore)(nil)
-	_ registry.GCStore        = (*MemStore)(nil)
+	_ registry.BlobRefStore          = (*MemStore)(nil)
+	_ registry.IntentStore           = (*MemStore)(nil)
+	_ registry.LocationStore         = (*MemStore)(nil)
+	_ registry.EncryptionParamsStore = (*MemStore)(nil)
+	_ registry.InclusionStore        = (*MemStore)(nil)
+	_ registry.MultipartStore        = (*MemStore)(nil)
+	_ registry.GCStore               = (*MemStore)(nil)
 )
 
 func cloneBytes(b []byte) []byte {
@@ -123,10 +124,6 @@ func (m *MemStore) DeleteIntent(_ context.Context, digest []byte) error {
 // LocationStore ==============================================================
 
 func (m *MemStore) PutLocation(_ context.Context, loc registry.BlobLocation) error {
-	// Match the Postgres store: reject a partial FEE set (see ValidateFEE).
-	if err := loc.ValidateFEE(); err != nil {
-		return err
-	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.locations[locKey{loc.Space, string(loc.Digest)}] = cloneLocation(loc)
@@ -151,6 +148,37 @@ func (m *MemStore) DeleteLocation(_ context.Context, space did.DID, digest []byt
 	return nil
 }
 
+// EncryptionParamsStore ======================================================
+
+func (m *MemStore) PutEncryptionParams(_ context.Context, params registry.BlobEncryptionParams) error {
+	// Match the Postgres store, whose columns are all NOT NULL.
+	if err := params.Validate(); err != nil {
+		return err
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.encParams[locKey{params.Space, string(params.Digest)}] = cloneEncryptionParams(params)
+	return nil
+}
+
+func (m *MemStore) GetEncryptionParams(_ context.Context, space did.DID, digest []byte) (*registry.BlobEncryptionParams, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	params, ok := m.encParams[locKey{space, string(digest)}]
+	if !ok {
+		return nil, registry.ErrNotFound
+	}
+	cp := cloneEncryptionParams(params)
+	return &cp, nil
+}
+
+func (m *MemStore) DeleteEncryptionParams(_ context.Context, space did.DID, digest []byte) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	delete(m.encParams, locKey{space, string(digest)})
+	return nil
+}
+
 // ParkStore ==================================================================
 
 func (m *MemStore) PutPark(_ context.Context, p registry.BlobPark) error {
@@ -387,17 +415,24 @@ func cloneSession(s registry.MultipartSession) registry.MultipartSession {
 	return s
 }
 
-// cloneLocation deep-copies a BlobLocation's byte-slice fields (the digest and
-// the FEE wrap material) so the stored copy and any returned copy never alias
-// the caller's slices. Nil slices stay nil, preserving "unencrypted blob".
+// cloneLocation deep-copies a BlobLocation's digest so the stored copy and any
+// returned copy never alias the caller's slice.
 func cloneLocation(loc registry.BlobLocation) registry.BlobLocation {
 	loc.Digest = cloneBytes(loc.Digest)
-	loc.RegionWrappedCEK = cloneBytes(loc.RegionWrappedCEK)
-	loc.BaseNonce = cloneBytes(loc.BaseNonce)
-	loc.ProtectedHeader = cloneBytes(loc.ProtectedHeader)
 	return loc
 }
 
+// cloneEncryptionParams deep-copies a BlobEncryptionParams' byte-slice fields —
+// the digest and the key material — so the stored copy and any returned copy
+// never alias the caller's slices.
+func cloneEncryptionParams(p registry.BlobEncryptionParams) registry.BlobEncryptionParams {
+	p.Digest = cloneBytes(p.Digest)
+	p.RegionWrappedCEK = cloneBytes(p.RegionWrappedCEK)
+	p.BaseNonce = cloneBytes(p.BaseNonce)
+	p.AAD = cloneBytes(p.AAD)
+	return p
+}
+
 func clonePart(p registry.MultipartPart) registry.MultipartPart {
 	p.ETagMD5 = cloneBytes(p.ETagMD5)
 	if p.BlobDigests != nil {