From e63680afb901719a55ae18a25623ddc8846a9295 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 25 Oct 2026 20:54:11 +1100 Subject: [PATCH 1/3] feat(postgres): audit package and harness secret writes --- .../postgres/harness_secrets.go | 25 +++- .../postgres/installed_packages.go | 123 ++++++++++++++++-- .../postgresdb/harness_secrets.sql.go | 16 +++ .../postgres/queries/harness_secrets.sql | 3 + 4 files changed, 157 insertions(+), 10 deletions(-) diff --git a/internal/infrastructure/postgres/harness_secrets.go b/internal/infrastructure/postgres/harness_secrets.go index e6424afce..eadb10d83 100644 --- a/internal/infrastructure/postgres/harness_secrets.go +++ b/internal/infrastructure/postgres/harness_secrets.go @@ -65,12 +65,33 @@ func (s *EDA) PutHarnessSecret(ctx context.Context, secret harnesssecret.Secret) if err != nil { return err } - if err := s.q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{ + tx, err := s.pool.Begin(ctx) + if err != nil { + return err + } + defer func() { _ = tx.Rollback(ctx) }() + q := postgresdb.New(tx) + exists, err := q.HarnessSecretExists(ctx, postgresdb.HarnessSecretExistsParams{Org: secret.Org, Service: secret.Service}) + if err != nil { + return fmt.Errorf("postgres: check harness secret: %w", err) + } + if err := q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{ Org: secret.Org, Service: secret.Service, SecretEnc: sealed, }); err != nil { return fmt.Errorf("postgres: put harness secret: %w", err) } - return nil + // The trail records that the credential changed, never any part of it: no + // access token, refresh token or ciphertext. A first capture has a nil old + // side, which the read model reports as a create. + var oldValue []byte + if exists { + oldValue = auditJSON(map[string]bool{"changed": true}) + } + if err := insertAudit(ctx, q, "harness_secrets", secret.Service, "credential", oldValue, + auditJSON(map[string]bool{"changed": true}), 0, secret.Org); err != nil { + return err + } + return tx.Commit(ctx) } // sealHarnessSecret encrypts the token set under HarnessSecretDomain. An diff --git a/internal/infrastructure/postgres/installed_packages.go b/internal/infrastructure/postgres/installed_packages.go index 9b6411d1c..3986506c5 100644 --- a/internal/infrastructure/postgres/installed_packages.go +++ b/internal/infrastructure/postgres/installed_packages.go @@ -59,9 +59,36 @@ func (s *InstalledPackages) Install(ctx context.Context, p storepkg.Installed) e if err := insertInstalledRequirements(ctx, q, p); err != nil { return err } + if err := insertAudit(ctx, q, "installed_packages", p.Name, "install", nil, + auditJSON(packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: p.UpdatePolicy}), 0, p.OrgID); err != nil { + return err + } return tx.Commit(ctx) } +// packageAuditValue is the non-secret state an installed_packages audit row +// records: the pin and the policy that decides whether it follows the +// catalogue. Pending marks a pin waiting for approval. +type packageAuditValue struct { + Reference string `json:"reference"` + Digest string `json:"digest"` + UpdatePolicy string `json:"update_policy,omitempty"` + Pending bool `json:"pending,omitempty"` +} + +// getInstalledRow reads one package inside the caller's transaction, mapping +// an absent row to storepkg.ErrNotFound. +func getInstalledRow(ctx context.Context, q *postgresdb.Queries, orgID, name string) (postgresdb.GetInstalledPackageRow, error) { + row, err := q.GetInstalledPackage(ctx, postgresdb.GetInstalledPackageParams{OrgID: orgID, Name: name}) + if errors.Is(err, pgx.ErrNoRows) { + return postgresdb.GetInstalledPackageRow{}, storepkg.ErrNotFound + } + if err != nil { + return postgresdb.GetInstalledPackageRow{}, err + } + return row, nil +} + func checkInstalledRequirements(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed) error { for _, required := range p.Descriptor.Requires { existing, err := q.GetInstalledPackage(ctx, postgresdb.GetInstalledPackageParams{OrgID: p.OrgID, Name: required.Name}) @@ -126,6 +153,10 @@ func (s *InstalledPackages) Remove(ctx context.Context, orgID, name string) erro if err := q.LockInstalledPackages(ctx, orgID); err != nil { return err } + current, err := getInstalledRow(ctx, q, orgID, name) + if err != nil { + return err + } rows, err := q.DeleteInstalledPackage(ctx, postgresdb.DeleteInstalledPackageParams{OrgID: orgID, Name: name}) if pgCode(err) == "23001" { return storepkg.ErrRequired @@ -136,6 +167,10 @@ func (s *InstalledPackages) Remove(ctx context.Context, orgID, name string) erro if rows == 0 { return storepkg.ErrNotFound } + if err := insertAudit(ctx, q, "installed_packages", name, "remove", + auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), nil, 0, orgID); err != nil { + return err + } return tx.Commit(ctx) } @@ -150,7 +185,17 @@ func (s *InstalledPackages) Accept(ctx context.Context, orgID, name string, auth if err != nil { return err } - rows, err := postgresdb.New(s.pool).AcceptInstalledPackageAuthority(ctx, postgresdb.AcceptInstalledPackageAuthorityParams{ + tx, err := s.pool.Begin(ctx) + if err != nil { + return err + } + defer func() { _ = tx.Rollback(ctx) }() + q := postgresdb.New(tx) + current, err := getInstalledRow(ctx, q, orgID, name) + if err != nil { + return err + } + rows, err := q.AcceptInstalledPackageAuthority(ctx, postgresdb.AcceptInstalledPackageAuthorityParams{ OrgID: orgID, Name: name, AcceptedAuthority: encoded, }) if err != nil { @@ -159,7 +204,11 @@ func (s *InstalledPackages) Accept(ctx context.Context, orgID, name string, auth if rows == 0 { return storepkg.ErrNotFound } - return nil + if err := insertAudit(ctx, q, "installed_packages", name, "accept_authority", + current.AcceptedAuthority, encoded, 0, orgID); err != nil { + return err + } + return tx.Commit(ctx) } // updateColumns are the nullable pending and previous pin columns of a row. @@ -180,7 +229,17 @@ func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, if err != nil { return err } - rows, err := postgresdb.New(s.pool).SetInstalledPackagePending(ctx, postgresdb.SetInstalledPackagePendingParams{ + tx, err := s.pool.Begin(ctx) + if err != nil { + return err + } + defer func() { _ = tx.Rollback(ctx) }() + q := postgresdb.New(tx) + current, err := getInstalledRow(ctx, q, orgID, name) + if err != nil { + return err + } + rows, err := q.SetInstalledPackagePending(ctx, postgresdb.SetInstalledPackagePendingParams{ OrgID: orgID, Name: name, PendingReference: pgtype.Text{String: pending.Reference, Valid: true}, PendingDigest: pgtype.Text{String: pending.Digest, Valid: true}, PendingAuthority: encoded, }) if err != nil { @@ -189,7 +248,12 @@ func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, if rows == 0 { return storepkg.ErrNotFound } - return nil + if err := insertAudit(ctx, q, "installed_packages", name, "update", + auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), + auditJSON(packageAuditValue{Reference: pending.Reference, Digest: pending.Digest, UpdatePolicy: current.UpdatePolicy, Pending: true}), 0, orgID); err != nil { + return err + } + return tx.Commit(ctx) } // Replace swaps the live pin under the org's package lock. Another package @@ -218,6 +282,10 @@ func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed) e if err := q.LockInstalledPackages(ctx, p.OrgID); err != nil { return err } + current, err := getInstalledRow(ctx, q, p.OrgID, p.Name) + if err != nil { + return err + } dependents, err := q.CountInstalledDependents(ctx, postgresdb.CountInstalledDependentsParams{OrgID: p.OrgID, RequiredName: p.Name}) if err != nil { return err @@ -238,15 +306,39 @@ func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed) e if rows == 0 { return storepkg.ErrNotFound } - if err := q.DeleteInstalledRequirements(ctx, postgresdb.DeleteInstalledRequirementsParams{OrgID: p.OrgID, PackageName: p.Name}); err != nil { + if err := replaceInstalledRequirements(ctx, q, p); err != nil { return err } - if err := insertInstalledRequirements(ctx, q, p); err != nil { + // Replace serves three actions; the row it replaced says which. + if err := insertAudit(ctx, q, "installed_packages", p.Name, replaceAction(current, p.Digest), + auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy, Pending: current.PendingDigest.Valid}), + auditJSON(packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: current.UpdatePolicy}), 0, p.OrgID); err != nil { return err } return tx.Commit(ctx) } +// replaceAction names the operation behind a Replace. A pending pin matching +// the new one is the approval of that update, and the pin being restored from +// the previous one is a rollback; anything else is a plain update. +func replaceAction(current postgresdb.GetInstalledPackageRow, digest string) string { + switch { + case current.PendingDigest.Valid && current.PendingDigest.String == digest: + return "approve_update" + case current.PreviousDigest.Valid && current.PreviousDigest.String == digest: + return "rollback" + } + return "update" +} + +// replaceInstalledRequirements rebuilds p's requirement edges. +func replaceInstalledRequirements(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed) error { + if err := q.DeleteInstalledRequirements(ctx, postgresdb.DeleteInstalledRequirementsParams{OrgID: p.OrgID, PackageName: p.Name}); err != nil { + return err + } + return insertInstalledRequirements(ctx, q, p) +} + func installedFromRow(orgID, name, reference, digest string, raw, layer []byte, updatePolicy string, accepted []byte, update updateColumns) (storepkg.Installed, error) { var descriptor storepkg.Descriptor if err := json.Unmarshal(raw, &descriptor); err != nil { @@ -291,7 +383,17 @@ func pgCode(err error) string { } func (s *InstalledPackages) SetUpdatePolicy(ctx context.Context, orgID, name, policy string) error { - rows, err := postgresdb.New(s.pool).SetInstalledPackageUpdatePolicy(ctx, postgresdb.SetInstalledPackageUpdatePolicyParams{ + tx, err := s.pool.Begin(ctx) + if err != nil { + return err + } + defer func() { _ = tx.Rollback(ctx) }() + q := postgresdb.New(tx) + current, err := getInstalledRow(ctx, q, orgID, name) + if err != nil { + return err + } + rows, err := q.SetInstalledPackageUpdatePolicy(ctx, postgresdb.SetInstalledPackageUpdatePolicyParams{ OrgID: orgID, Name: name, UpdatePolicy: policy, }) if err != nil { @@ -300,7 +402,12 @@ func (s *InstalledPackages) SetUpdatePolicy(ctx context.Context, orgID, name, po if rows == 0 { return storepkg.ErrNotFound } - return nil + if err := insertAudit(ctx, q, "installed_packages", name, "update_policy", + auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), + auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: policy}), 0, orgID); err != nil { + return err + } + return tx.Commit(ctx) } func (s *InstalledPackages) ListAutoUpdate(ctx context.Context) ([]storepkg.OrgPackage, error) { diff --git a/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go b/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go index 2f15909ba..048d4ad17 100644 --- a/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go +++ b/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go @@ -36,6 +36,22 @@ func (q *Queries) GetHarnessSecret(ctx context.Context, arg GetHarnessSecretPara return i, err } +const harnessSecretExists = `-- name: HarnessSecretExists :one +SELECT EXISTS (SELECT 1 FROM harness_secrets WHERE org = $1 AND service = $2) +` + +type HarnessSecretExistsParams struct { + Org string + Service string +} + +func (q *Queries) HarnessSecretExists(ctx context.Context, arg HarnessSecretExistsParams) (bool, error) { + row := q.db.QueryRow(ctx, harnessSecretExists, arg.Org, arg.Service) + var exists bool + err := row.Scan(&exists) + return exists, err +} + const putHarnessSecret = `-- name: PutHarnessSecret :exec INSERT INTO harness_secrets (org, service, secret_enc, updated_at) VALUES ($1, $2, $3, now()) diff --git a/internal/infrastructure/postgres/queries/harness_secrets.sql b/internal/infrastructure/postgres/queries/harness_secrets.sql index a3a588c49..b731ad0af 100644 --- a/internal/infrastructure/postgres/queries/harness_secrets.sql +++ b/internal/infrastructure/postgres/queries/harness_secrets.sql @@ -7,6 +7,9 @@ SELECT org, service, secret_enc, updated_at FROM harness_secrets WHERE org = $1 AND service = $2; +-- name: HarnessSecretExists :one +SELECT EXISTS (SELECT 1 FROM harness_secrets WHERE org = $1 AND service = $2); + -- name: PutHarnessSecret :exec INSERT INTO harness_secrets (org, service, secret_enc, updated_at) VALUES ($1, $2, $3, now()) From f8c610ea5f1931836d6bc63ca5af63f9fc9475b0 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 25 Oct 2026 21:03:00 +1100 Subject: [PATCH 2/3] fix(postgres): correct package and secret audit coverage --- internal/domain/storepkg/installed.go | 14 ++- internal/domain/storepkg/update.go | 17 ++-- .../postgres/harness_secrets.go | 27 +++--- .../postgres/installed_packages.go | 91 ++++++++++++------- .../postgresdb/harness_secrets.sql.go | 29 ++---- .../postgres/queries/harness_secrets.sql | 10 +- 6 files changed, 111 insertions(+), 77 deletions(-) diff --git a/internal/domain/storepkg/installed.go b/internal/domain/storepkg/installed.go index 8cb30dffe..713d3408a 100644 --- a/internal/domain/storepkg/installed.go +++ b/internal/domain/storepkg/installed.go @@ -65,14 +65,24 @@ type Repository interface { UpdateRecords } +// Actions a swap of the live pin records in the audit trail. +const ( + // ActionUpdate applies a catalogue update, or stages one as pending. + ActionUpdate = "update" + // ActionApproveUpdate applies the pending update and accepts its authority. + ActionApproveUpdate = "approve_update" + // ActionRollback restores the previous pin and its accepted authority. + ActionRollback = "rollback" +) + // UpdateRecords is the part of Repository the update lifecycle writes. type UpdateRecords interface { // SetPending records an update waiting for approval, leaving the live pin. SetPending(ctx context.Context, orgID, name string, pending Pin, declared Authority) error // Replace swaps the live pin, descriptor, layer and accepted authority for // next's, keeping the replaced pin and its accepted authority as Previous - // and clearing Pending. - Replace(ctx context.Context, next Installed) error + // and clearing Pending. action names the operation in the audit trail. + Replace(ctx context.Context, next Installed, action string) error // SetUpdatePolicy sets whether a package follows the catalogue on its own. SetUpdatePolicy(ctx context.Context, orgID, name, policy string) error // ListAutoUpdate names every installed package, in any org, whose policy diff --git a/internal/domain/storepkg/update.go b/internal/domain/storepkg/update.go index bf6e9627e..80806efc2 100644 --- a/internal/domain/storepkg/update.go +++ b/internal/domain/storepkg/update.go @@ -4,6 +4,8 @@ import ( "context" "errors" "fmt" + + "github.com/samcharles93/archie-core/internal/domain/access" ) // Update policies. Manual is the default; an auto package follows the @@ -30,8 +32,11 @@ func (s Service) SetPackageUpdatePolicy(ctx context.Context, orgID, name, policy return s.Store.Get(ctx, orgID, name) } -// UpdateAuto runs UpdatePackage for every auto package. +// UpdateAuto runs UpdatePackage for every auto package. No caller is behind +// it, so the audit trail attributes it to the process doing the work. func (s Service) UpdateAuto(ctx context.Context) error { + ctx = access.WithActor(ctx, "archie-state-store") + ctx = access.WithSource(ctx, "package auto-update") return updateAuto(ctx, s.Store, s) } @@ -102,7 +107,7 @@ func (s Service) UpdatePackage(ctx context.Context, orgID, name string) (Install return s.Store.Get(ctx, orgID, name) } next.AcceptedAuthority = installed.AcceptedAuthority - return s.swap(ctx, installed, next, contents) + return s.swap(ctx, installed, next, contents, ActionUpdate) } return Installed{}, fmt.Errorf("catalogue package %q: %w", name, ErrNotFound) } @@ -123,7 +128,7 @@ func (s Service) ApprovePackageUpdate(ctx context.Context, orgID, name string) ( } accepted := next.Descriptor.Authority next.AcceptedAuthority = &accepted - return s.swap(ctx, installed, next, contents) + return s.swap(ctx, installed, next, contents, ActionApproveUpdate) } // RollbackPackage reinstalls the previous digest with the authority accepted @@ -141,7 +146,7 @@ func (s Service) RollbackPackage(ctx context.Context, orgID, name string) (Insta return Installed{}, err } next.AcceptedAuthority = installed.PreviousAccepted - return s.swap(ctx, installed, next, contents) + return s.swap(ctx, installed, next, contents, ActionRollback) } // prepare fetches and validates the package at pin and resolves its @@ -167,13 +172,13 @@ func (s Service) prepare(ctx context.Context, orgID, name string, pin Pin) (Inst // swap replaces installed with next: old contributions come out, new ones go // in, then the record flips. A failure puts the old contributions back so // the record, which still names the old pin, stays true. -func (s Service) swap(ctx context.Context, installed, next Installed, contents map[string]map[string][]byte) (Installed, error) { +func (s Service) swap(ctx context.Context, installed, next Installed, contents map[string]map[string][]byte, action string) (Installed, error) { if err := s.withdraw(ctx, installed); err != nil { return Installed{}, err } err := s.project(ctx, next, contents) if err == nil { - err = s.Store.Replace(ctx, next) + err = s.Store.Replace(ctx, next, action) } if err != nil { return Installed{}, errors.Join(err, s.withdraw(ctx, next), s.restore(ctx, installed)) diff --git a/internal/infrastructure/postgres/harness_secrets.go b/internal/infrastructure/postgres/harness_secrets.go index eadb10d83..858c4a1eb 100644 --- a/internal/infrastructure/postgres/harness_secrets.go +++ b/internal/infrastructure/postgres/harness_secrets.go @@ -71,24 +71,27 @@ func (s *EDA) PutHarnessSecret(ctx context.Context, secret harnesssecret.Secret) } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) - exists, err := q.HarnessSecretExists(ctx, postgresdb.HarnessSecretExistsParams{Org: secret.Org, Service: secret.Service}) - if err != nil { - return fmt.Errorf("postgres: check harness secret: %w", err) - } - if err := q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{ + inserted, err := q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{ Org: secret.Org, Service: secret.Service, SecretEnc: sealed, - }); err != nil { + }) + if err != nil { return fmt.Errorf("postgres: put harness secret: %w", err) } // The trail records that the credential changed, never any part of it: no - // access token, refresh token or ciphertext. A first capture has a nil old - // side, which the read model reports as a create. + // access token, refresh token or ciphertext. The insert flag is read by the + // same statement, so a concurrent first capture is an update, not a second + // create. A first capture has a nil old side. var oldValue []byte - if exists { - oldValue = auditJSON(map[string]bool{"changed": true}) + if !inserted { + if oldValue, err = auditJSON(map[string]bool{"changed": true}); err != nil { + return err + } } - if err := insertAudit(ctx, q, "harness_secrets", secret.Service, "credential", oldValue, - auditJSON(map[string]bool{"changed": true}), 0, secret.Org); err != nil { + newValue, err := auditJSON(map[string]bool{"changed": true}) + if err != nil { + return err + } + if err := insertAudit(ctx, q, "harness_secrets", secret.Service, "credential", oldValue, newValue, 0, secret.Org); err != nil { return err } return tx.Commit(ctx) diff --git a/internal/infrastructure/postgres/installed_packages.go b/internal/infrastructure/postgres/installed_packages.go index 3986506c5..7f47feb9c 100644 --- a/internal/infrastructure/postgres/installed_packages.go +++ b/internal/infrastructure/postgres/installed_packages.go @@ -59,21 +59,37 @@ func (s *InstalledPackages) Install(ctx context.Context, p storepkg.Installed) e if err := insertInstalledRequirements(ctx, q, p); err != nil { return err } - if err := insertAudit(ctx, q, "installed_packages", p.Name, "install", nil, - auditJSON(packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: p.UpdatePolicy}), 0, p.OrgID); err != nil { + if err := auditPackage(ctx, q, p.OrgID, p.Name, "install", nil, + &packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: p.UpdatePolicy}); err != nil { return err } return tx.Commit(ctx) } // packageAuditValue is the non-secret state an installed_packages audit row -// records: the pin and the policy that decides whether it follows the -// catalogue. Pending marks a pin waiting for approval. +// records: the pin, the policy that decides whether it follows the catalogue, +// and a pending update's declared authority. Pending marks a pin waiting for +// approval. type packageAuditValue struct { - Reference string `json:"reference"` - Digest string `json:"digest"` - UpdatePolicy string `json:"update_policy,omitempty"` - Pending bool `json:"pending,omitempty"` + Reference string `json:"reference"` + Digest string `json:"digest"` + UpdatePolicy string `json:"update_policy,omitempty"` + Pending bool `json:"pending,omitempty"` + Authority json.RawMessage `json:"authority,omitempty"` +} + +// auditPackage writes one installed_packages row. A nil side stays NULL, which +// the read model treats as a create or a delete. +func auditPackage(ctx context.Context, q *postgresdb.Queries, orgID, name, action string, oldValue, newValue *packageAuditValue) error { + oldJSON, err := auditJSON(oldValue) + if err != nil { + return err + } + newJSON, err := auditJSON(newValue) + if err != nil { + return err + } + return insertAudit(ctx, q, "installed_packages", name, action, oldJSON, newJSON, 0, orgID) } // getInstalledRow reads one package inside the caller's transaction, mapping @@ -167,8 +183,8 @@ func (s *InstalledPackages) Remove(ctx context.Context, orgID, name string) erro if rows == 0 { return storepkg.ErrNotFound } - if err := insertAudit(ctx, q, "installed_packages", name, "remove", - auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), nil, 0, orgID); err != nil { + if err := auditPackage(ctx, q, orgID, name, "remove", + &packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}, nil); err != nil { return err } return tx.Commit(ctx) @@ -191,6 +207,9 @@ func (s *InstalledPackages) Accept(ctx context.Context, orgID, name string, auth } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) + if err := q.LockInstalledPackages(ctx, orgID); err != nil { + return err + } current, err := getInstalledRow(ctx, q, orgID, name) if err != nil { return err @@ -235,6 +254,9 @@ func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) + if err := q.LockInstalledPackages(ctx, orgID); err != nil { + return err + } current, err := getInstalledRow(ctx, q, orgID, name) if err != nil { return err @@ -248,9 +270,11 @@ func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, if rows == 0 { return storepkg.ErrNotFound } - if err := insertAudit(ctx, q, "installed_packages", name, "update", - auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), - auditJSON(packageAuditValue{Reference: pending.Reference, Digest: pending.Digest, UpdatePolicy: current.UpdatePolicy, Pending: true}), 0, orgID); err != nil { + // The declared authority is recorded here because this is the only place + // it is known before approval. + if err := auditPackage(ctx, q, orgID, name, "update", + &packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}, + &packageAuditValue{Reference: pending.Reference, Digest: pending.Digest, UpdatePolicy: current.UpdatePolicy, Pending: true, Authority: encoded}); err != nil { return err } return tx.Commit(ctx) @@ -258,8 +282,8 @@ func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, // Replace swaps the live pin under the org's package lock. Another package // pinning this one's digest, or a requirement the new descriptor cannot -// meet, refuses the swap. -func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed) error { +// meet, refuses the swap. action names the operation in the audit trail. +func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed, action string) error { if err := p.Descriptor.Validate(); err != nil { return err } @@ -309,26 +333,26 @@ func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed) e if err := replaceInstalledRequirements(ctx, q, p); err != nil { return err } - // Replace serves three actions; the row it replaced says which. - if err := insertAudit(ctx, q, "installed_packages", p.Name, replaceAction(current, p.Digest), - auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy, Pending: current.PendingDigest.Valid}), - auditJSON(packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: current.UpdatePolicy}), 0, p.OrgID); err != nil { + // Approvals and rollbacks change the accepted authority as well as the pin. + if err := auditReplace(ctx, q, p, current, accepted, action); err != nil { return err } return tx.Commit(ctx) } -// replaceAction names the operation behind a Replace. A pending pin matching -// the new one is the approval of that update, and the pin being restored from -// the previous one is a rollback; anything else is a plain update. -func replaceAction(current postgresdb.GetInstalledPackageRow, digest string) string { - switch { - case current.PendingDigest.Valid && current.PendingDigest.String == digest: - return "approve_update" - case current.PreviousDigest.Valid && current.PreviousDigest.String == digest: - return "rollback" +// auditReplace records the pin swap, and for the actions that also change the +// accepted authority, that change as its own row. Both rows share the +// transaction's timestamp, so the read model groups them as one change set. +func auditReplace(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed, current postgresdb.GetInstalledPackageRow, accepted []byte, action string) error { + if err := auditPackage(ctx, q, p.OrgID, p.Name, action, + &packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy, Pending: current.PendingDigest.Valid}, + &packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: current.UpdatePolicy}); err != nil { + return err } - return "update" + if action != storepkg.ActionApproveUpdate && action != storepkg.ActionRollback { + return nil + } + return insertAudit(ctx, q, "installed_packages", p.Name, "accept_authority", current.AcceptedAuthority, accepted, 0, p.OrgID) } // replaceInstalledRequirements rebuilds p's requirement edges. @@ -389,6 +413,9 @@ func (s *InstalledPackages) SetUpdatePolicy(ctx context.Context, orgID, name, po } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) + if err := q.LockInstalledPackages(ctx, orgID); err != nil { + return err + } current, err := getInstalledRow(ctx, q, orgID, name) if err != nil { return err @@ -402,9 +429,9 @@ func (s *InstalledPackages) SetUpdatePolicy(ctx context.Context, orgID, name, po if rows == 0 { return storepkg.ErrNotFound } - if err := insertAudit(ctx, q, "installed_packages", name, "update_policy", - auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}), - auditJSON(packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: policy}), 0, orgID); err != nil { + if err := auditPackage(ctx, q, orgID, name, "update_policy", + &packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}, + &packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: policy}); err != nil { return err } return tx.Commit(ctx) diff --git a/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go b/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go index 048d4ad17..6a159263d 100644 --- a/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go +++ b/internal/infrastructure/postgres/postgresdb/harness_secrets.sql.go @@ -36,26 +36,11 @@ func (q *Queries) GetHarnessSecret(ctx context.Context, arg GetHarnessSecretPara return i, err } -const harnessSecretExists = `-- name: HarnessSecretExists :one -SELECT EXISTS (SELECT 1 FROM harness_secrets WHERE org = $1 AND service = $2) -` - -type HarnessSecretExistsParams struct { - Org string - Service string -} - -func (q *Queries) HarnessSecretExists(ctx context.Context, arg HarnessSecretExistsParams) (bool, error) { - row := q.db.QueryRow(ctx, harnessSecretExists, arg.Org, arg.Service) - var exists bool - err := row.Scan(&exists) - return exists, err -} - -const putHarnessSecret = `-- name: PutHarnessSecret :exec +const putHarnessSecret = `-- name: PutHarnessSecret :one INSERT INTO harness_secrets (org, service, secret_enc, updated_at) VALUES ($1, $2, $3, now()) ON CONFLICT (org, service) DO UPDATE SET secret_enc = EXCLUDED.secret_enc, updated_at = now() +RETURNING (xmax = 0) AS inserted ` type PutHarnessSecretParams struct { @@ -64,7 +49,11 @@ type PutHarnessSecretParams struct { SecretEnc string } -func (q *Queries) PutHarnessSecret(ctx context.Context, arg PutHarnessSecretParams) error { - _, err := q.db.Exec(ctx, putHarnessSecret, arg.Org, arg.Service, arg.SecretEnc) - return err +// inserted is true only when this statement created the row: xmax is zero for +// a fresh insert and nonzero for the upsert's update side. +func (q *Queries) PutHarnessSecret(ctx context.Context, arg PutHarnessSecretParams) (bool, error) { + row := q.db.QueryRow(ctx, putHarnessSecret, arg.Org, arg.Service, arg.SecretEnc) + var inserted bool + err := row.Scan(&inserted) + return inserted, err } diff --git a/internal/infrastructure/postgres/queries/harness_secrets.sql b/internal/infrastructure/postgres/queries/harness_secrets.sql index b731ad0af..3a8f70dbb 100644 --- a/internal/infrastructure/postgres/queries/harness_secrets.sql +++ b/internal/infrastructure/postgres/queries/harness_secrets.sql @@ -7,10 +7,10 @@ SELECT org, service, secret_enc, updated_at FROM harness_secrets WHERE org = $1 AND service = $2; --- name: HarnessSecretExists :one -SELECT EXISTS (SELECT 1 FROM harness_secrets WHERE org = $1 AND service = $2); - --- name: PutHarnessSecret :exec +-- inserted is true only when this statement created the row: xmax is zero for +-- a fresh insert and nonzero for the upsert's update side. +-- name: PutHarnessSecret :one INSERT INTO harness_secrets (org, service, secret_enc, updated_at) VALUES ($1, $2, $3, now()) -ON CONFLICT (org, service) DO UPDATE SET secret_enc = EXCLUDED.secret_enc, updated_at = now(); +ON CONFLICT (org, service) DO UPDATE SET secret_enc = EXCLUDED.secret_enc, updated_at = now() +RETURNING (xmax = 0) AS inserted; From 876c98406e8eee9fec6d8c81cd866dc781f5f91f Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 25 Oct 2026 21:10:02 +1100 Subject: [PATCH 3/3] fix(postgres): skip unchanged authority in package audit --- internal/infrastructure/postgres/installed_packages.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/internal/infrastructure/postgres/installed_packages.go b/internal/infrastructure/postgres/installed_packages.go index 7f47feb9c..021759411 100644 --- a/internal/infrastructure/postgres/installed_packages.go +++ b/internal/infrastructure/postgres/installed_packages.go @@ -1,6 +1,7 @@ package postgres import ( + "bytes" "context" "encoding/json" "errors" @@ -352,6 +353,10 @@ func auditReplace(ctx context.Context, q *postgresdb.Queries, p storepkg.Install if action != storepkg.ActionApproveUpdate && action != storepkg.ActionRollback { return nil } + // An unchanged authority, including none at all, is not an approval. + if bytes.Equal(current.AcceptedAuthority, accepted) { + return nil + } return insertAudit(ctx, q, "installed_packages", p.Name, "accept_authority", current.AcceptedAuthority, accepted, 0, p.OrgID) }