diff --git a/internal/httpapi/settings_write_test.go b/internal/httpapi/settings_write_test.go index 4deeab462..82443f9f0 100644 --- a/internal/httpapi/settings_write_test.go +++ b/internal/httpapi/settings_write_test.go @@ -139,6 +139,13 @@ func TestSetSettingProjectsTheWholeRequest(t *testing.T) { // one place — and `Setting.redacted` would mean two different things depending on // which operation produced it. Comparing the two responses is what makes a second // projection impossible to add without failing here. +// +// THE CREDENTIAL-BEARING CASE RUNS AGAINST A FAKE ROLE (`&roleSettings{}`, +// which accepts any write), not workapi.ValidateSettingWrite. Since GH#7559 +// the real role refuses notion.token — and every other config.IsYamlOnlyKey +// key — before this projection ever runs, so this case now exercises only the +// redaction PROJECTION in isolation: if a real server's role ever did accept +// a credential write, this is the shape the response would have to take. func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { for _, tc := range []struct { name string @@ -146,7 +153,7 @@ func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { value string }{ {name: "an ordinary key", key: "status.custom", value: "awaiting_review:active"}, - {name: "a credential-bearing key", key: "notion.token", value: "shhh-real-secret"}, + {name: "a credential-bearing key, against a fake role that accepts it", key: "notion.token", value: "shhh-real-secret"}, {name: "a key stored empty", key: "notes", value: ""}, } { t.Run(tc.name, func(t *testing.T) { @@ -173,15 +180,19 @@ func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { } // TestSetSettingWithholdsACredentialItJustAccepted is the doctrine, asserted -// directly rather than only through the equality above: the write is PERMITTED -// and the value does not come back. +// directly rather than only through the equality above: AGAINST A ROLE THAT +// ACCEPTS THE WRITE, the response is PERMITTED and the value does not come +// back. // -// PERMITTED because redaction is a rule about DISCLOSURE. The role refuses no -// credential-bearing key — `bd config set`'s own secret guard is about writing -// one into a git-tracked config.yaml, a different plane with a different hazard — -// and a writer already holds the value, so refusing here would protect nothing -// while leaving a workspace's credentials visible as PRESENT and permanently -// unconfigurable through this door. +// IT RUNS AGAINST A FAKE ROLE (`&roleSettings{}`), not +// workapi.ValidateSettingWrite. Since GH#7559 the real role refuses every +// config.IsYamlOnlyKey key — including every tracker credential, writing +// them to a git-tracked config.yaml instead via `bd config set`'s own guard +// — because that plane is the Dolt config table, synced to every remote on +// push/pull. What this test pins is narrower: IF a role's write succeeds, +// the HTTP layer's redaction projection must withhold the value from its own +// answer regardless, which is what the handler owns and the only part of +// this doctrine the httpapi package can prove on its own. func TestSetSettingWithholdsACredentialItJustAccepted(t *testing.T) { const key = "notion.token" if !config.IsSecretKey(key) { diff --git a/internal/httpclient/roles_aux.go b/internal/httpclient/roles_aux.go index 213224d12..4a1a8f1ab 100644 --- a/internal/httpclient/roles_aux.go +++ b/internal/httpclient/roles_aux.go @@ -9,6 +9,7 @@ import ( "net/url" "strings" + "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/httpapi/apigen" "github.com/steveyegge/beads/internal/httpclient/wire" "github.com/steveyegge/beads/internal/types" @@ -241,6 +242,18 @@ func validateSettingWrite(key, value string) error { if err := validateSettingKey(key); err != nil { return err } + // config.YamlOnlyKeys — startup settings and the tracker secrets — must + // live in the workspace's local config.yaml, never in this plane's + // row-per-key storage, which is the Dolt config table: a SYNCED table + // replicated to every remote on push/pull. `bd config set` already + // refuses these at its own door; this mirror and the server-side + // workapi.ValidateSettingWrite it is pinned to (wave2c_config_test.go's + // TestSettingWriteValidationMatchesTheSharedValidator) are two more doors + // onto the same plane and must refuse the same set (GH#7559). + if config.IsYamlOnlyKey(key) { + return invalid("%q must be set in the workspace's local config.yaml (bd config set %s ), not written here: "+ + "this plane is the Dolt config table, which syncs to every remote on push/pull", key, key) + } // The prefix is owned by `bd init --prefix`, `bd bootstrap` and // `bd rename-prefix`, each of which does work this plane cannot: rewriting // existing ids, or seeding a workspace that has none. Storing a new one here diff --git a/internal/httpclient/served_config_write_test.go b/internal/httpclient/served_config_write_test.go index 3596dff56..04d49a9f9 100644 --- a/internal/httpclient/served_config_write_test.go +++ b/internal/httpclient/served_config_write_test.go @@ -26,29 +26,20 @@ import ( // SERVER's, and a stub transport would let this file assert whatever it liked // about them. -// TestServedConfigWriteAnswersTheReadThatFollowsIt is the redaction doctrine, -// pinned on both sides of the one key it changes anything for. +// TestServedConfigWriteAnswersTheReadThatFollowsIt pins GH#7559 end to end +// against a real served role, beside the unrelated transcription property the +// ordinary key below it was always here to prove. // -// The operation PERMITS a credential-bearing write and WITHHOLDS the value from -// its own answer — one projection serves the write and the read, so the body of -// a PUT is byte-identical to the body of the GET after it. That leaves a -// successful write whose `value` member is absent, and the role's result has no -// spelling for "withheld": reporting "" would tell a caller the plane holds -// nothing under that key, which is the write-side version of the confusion -// RedactedSettingError exists to prevent on the read side. -// -// So the client answers with the value it SENT, and this asserts why that is -// honest rather than convenient: the value really is stored, read RAW from the -// reference store past the wire that hid it. -// -// WHAT THIS CASE CANNOT SAY is that the ordinary key beside it is TRANSCRIBED -// off the answer rather than echoed from the request. Against a correct server -// the two are byte-identical — the operation promises the stored value equals -// the value sent for every key it accepts — so the difference is pinned where it -// is observable, against a transport that answers something else: -// TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest. The ordinary -// key runs here anyway, because a client that transcribed the WRONG member would -// fail it. +// BEFORE GH#7559 this case pinned the redaction doctrine: a credential-bearing +// write was PERMITTED and only the ANSWER withheld the value. That doctrine +// was wrong for this door — the credential landed in the Dolt config table, +// a table `bd dolt push`/pull replicates to every remote — so the fix refuses +// the write instead of merely hiding its result. There is nothing left for +// this case to prove about REDACTION on a key workapi.ValidateSettingWrite now +// refuses outright; the httpapi package's fake-role tests +// (TestSetSettingAnswersWhatTheReadWouldAnswer, TestSetSettingWithholdsACredentialItJustAccepted) +// keep pinning what the redaction PROJECTION does if a role ever did accept +// such a write. func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { e := newServedEnv(t, "hcfgw1") ctx := t.Context() @@ -56,32 +47,28 @@ func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { const secretKey = "notion.token" const secret = "shhh-real-secret" - res, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: secretKey, Value: secret}) - if err != nil { - t.Fatalf("SetSetting on a credential-bearing key = %v; the write is permitted and only the ANSWER withholds", err) - } - if res.Key != secretKey { - t.Errorf("SetSetting echoed key %q, want %q", res.Key, secretKey) - } - if res.Value != secret { - t.Errorf("SetSetting reported value %q, want %q: the answer withheld it, and \"\" would say the plane stores nothing there", - res.Value, secret) + _, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: secretKey, Value: secret}) + if !errors.Is(err, issueops.ErrValidation) { + t.Fatalf("SetSetting on a credential-bearing key = %v, want ErrValidation: "+ + "this plane is the Dolt config table, synced to every remote on push/pull", err) } - // Read RAW, past the role and past the wire: the point is that the value the - // response would not repeat IS the value the workspace now holds. + // Read RAW, past the role and past the wire: nothing was written. stored, err := e.reference.GetConfig(ctx, secretKey) if err != nil { - t.Fatalf("read the stored credential back from the reference store: %v", err) + t.Fatalf("read the reference store for the key that must not have been written: %v", err) } - if stored != secret { - t.Errorf("the workspace stores %q under %q, want %q", stored, secretKey, secret) + if stored != "" { + t.Errorf("the workspace stores %q under %q, want nothing: the refused write must not have reached the store", stored, secretKey) } - // And the READ that follows still withholds, which is the other half of "the - // PUT body is the GET body": a write does not unlock the key it just wrote. + // The READ side is unchanged by this fix and keeps its own doctrine: a + // GetSetting on a credential-bearing key withholds unconditionally, keyed + // on the KEY pattern rather than on whether anything is actually stored + // there — confirmed empirically (this is not something the write-side fix + // touches, so the refused write above leaves it exactly as it always was). if _, err := settings.GetSetting(ctx, issueops.GetSettingRequest{Key: secretKey}); !errors.Is(err, ErrSettingRedacted) { - t.Errorf("GetSetting after the write = %v, want ErrSettingRedacted; the write does not unlock the read", err) + t.Errorf("GetSetting on a credential-bearing key = %v, want ErrSettingRedacted regardless of whether a write ever reached the store", err) } // The ordinary key is TRANSCRIBED, not echoed. The server answers this one @@ -90,7 +77,7 @@ func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { // something else. const plainKey = "custom.hcfgw1-plain" const plain = " spaces and , commas " - res, err = settings.SetSetting(ctx, issueops.SetSettingRequest{Key: plainKey, Value: plain}) + res, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: plainKey, Value: plain}) if err != nil { t.Fatalf("SetSetting on an ordinary key: %v", err) } diff --git a/internal/httpclient/wave2c_config_test.go b/internal/httpclient/wave2c_config_test.go index 300233fba..42affd8de 100644 --- a/internal/httpclient/wave2c_config_test.go +++ b/internal/httpclient/wave2c_config_test.go @@ -47,7 +47,7 @@ func TestSettingWriteValidationMatchesTheSharedValidator(t *testing.T) { key string value string }{ - {"an ordinary key", "routing.default", "core"}, + {"an ordinary key", "notes", "core"}, {"an empty key", "", "x"}, {"a blank key", " ", "x"}, {"the protected key", issueops.SettingKeyIssuePrefix, "bd"}, @@ -57,6 +57,10 @@ func TestSettingWriteValidationMatchesTheSharedValidator(t *testing.T) { {"an empty custom status", issueops.SettingKeyStatusCustom, ""}, {"a custom type list", issueops.SettingKeyTypesCustom, "not:a:status"}, {"a key that only LOOKS protected", "issue_prefix_backup", "bd"}, + // config.IsYamlOnlyKey, GH#7559: exact-match (a tracker secret) and + // prefix-match (a whole family, e.g. routing.*) both refuse here now. + {"a yaml-only key, exact match", "github.token", "ghp_x"}, + {"a yaml-only key, prefix match", "routing.default", "core"}, } { t.Run(tc.name, func(t *testing.T) { mine := validateSettingWrite(tc.key, tc.value) @@ -203,13 +207,21 @@ func TestConfigWritesDialTheKeyInThePath(t *testing.T) { // right answer: the projection withholds the value it just accepted, so there is // nothing to transcribe and the request is the only honest source. Both arms in // one case so neither can be satisfied by a body that always does one of them. +// +// BOTH ARMS USE AN ORDINARY KEY. The redacted/not-redacted branch is driven by +// the fake answer's own Redacted field, not by the key name, and since GH#7559 +// a real credential-bearing key (or any other config.IsYamlOnlyKey key) never +// reaches this transport at all — validateSettingWrite refuses it client-side +// first. That doctrine has its own pin (TestSettingWriteValidationMatchesTheSharedValidator); +// this case is only about what the client does with the answer once a write is +// accepted. func TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest(t *testing.T) { const sent = "what the caller sent" stored := "what the server stored" - plain := &settingAnswerWire{answer: apigen.Setting{Key: "routing.default", Value: &stored}} + plain := &settingAnswerWire{answer: apigen.Setting{Key: "notes", Value: &stored}} res, err := settingsOver(t, plain).SetSetting(context.Background(), - issueops.SetSettingRequest{Key: "routing.default", Value: sent}) + issueops.SetSettingRequest{Key: "notes", Value: sent}) if err != nil { t.Fatalf("SetSetting: %v", err) } @@ -217,15 +229,15 @@ func TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest(t *testing.T) t.Errorf("SetSetting reported %q, want the answer's %q: the result is what the workspace holds, "+ "and echoing the request would report a value it does not", res.Value, stored) } - if res.Key != "routing.default" { + if res.Key != "notes" { t.Errorf("SetSetting reported key %q, want the answer's", res.Key) } - withheld := &settingAnswerWire{answer: apigen.Setting{Key: "notion.token", Redacted: true}} + withheld := &settingAnswerWire{answer: apigen.Setting{Key: "custom.thing", Redacted: true}} res, err = settingsOver(t, withheld).SetSetting(context.Background(), - issueops.SetSettingRequest{Key: "notion.token", Value: sent}) + issueops.SetSettingRequest{Key: "custom.thing", Value: sent}) if err != nil { - t.Fatalf("SetSetting on a credential-bearing key: %v", err) + t.Fatalf("SetSetting on an answer that redacts: %v", err) } if res.Value != sent { t.Errorf("SetSetting on a withheld answer reported %q, want the request's %q: \"\" would say the plane "+ diff --git a/internal/notion/auth.go b/internal/notion/auth.go index f8c3bb6c4..b4e5ab112 100644 --- a/internal/notion/auth.go +++ b/internal/notion/auth.go @@ -48,14 +48,13 @@ type ConfigReader interface { // clears the file and any row an older bd left behind. That matters because the // config table's contents are replicated by `bd dolt push`. // -// ONE DOOR IS STILL OPEN, and this comment deliberately does not claim -// otherwise: the routing lives in the CLI command, not at the write chokepoint, -// so PUT /v0/beads/config/notion.token — `bd serve`, and the dashboard behind -// it — still writes the row with no refusal. That hole is not Notion's; it is -// identical for github.token, jira.api_token, linear.api_key and ado.pat, which -// is why closing it belongs at the role (workapi.ValidateSettingWrite / -// SetSetting), where every tracker credential gets the rule in one change, -// rather than here. Tracked as follow-up to GH#6676. +// THE DOOR CLOSED IN GH#7559: PUT /v0/beads/config/notion.token — `bd +// serve`, and the dashboard behind it — now refuses the write at the role +// (workapi.ValidateSettingWrite and the httpclient-side mirror it is pinned +// to), the same chokepoint every tracker credential refuses through, since +// the routing used to live only in the CLI command, not at the write +// chokepoint, and github.token/jira.api_token/linear.api_key/ado.pat shared +// the identical hole. // // The database read below therefore remains, both as the upgrade path for a // workspace configured before the key moved and as the reader for anything that diff --git a/internal/workapi/workspaceconfig.go b/internal/workapi/workspaceconfig.go index 1ca797ad9..cc713b3df 100644 --- a/internal/workapi/workspaceconfig.go +++ b/internal/workapi/workspaceconfig.go @@ -4,6 +4,7 @@ import ( "fmt" "strings" + "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/storage/kvkeys" "github.com/steveyegge/beads/internal/types" "github.com/steveyegge/beads/issueops" @@ -42,6 +43,21 @@ func ValidateSettingWrite(key, value string) (string, error) { if _, err := ValidateSettingKey(key); err != nil { return "", err } + // config.YamlOnlyKeys — startup settings and the tracker secrets + // (github.token, linear.api_key, jira.api_token, gitlab.token, ado.pat) — + // must live in the workspace's local config.yaml, never in this plane's + // row-per-key storage: that storage is the Dolt config table, which is a + // SYNCED table (bd dolt push/pull, DOLT_CLONE, DOLT_PULL all replicate + // it). `bd config set` already refuses these at its own door; this is + // the only other door onto this plane (the settings HTTP surface bd + // serve and its dashboard expose), and it had no such rule, so a secret + // PUT through it landed in the synced table and reached every remote on + // the next push (GH#7559). + if config.IsYamlOnlyKey(key) { + return "", fmt.Errorf("%w: %q must be set in the workspace's local config.yaml (bd config set %s ), not written here: "+ + "this plane is the Dolt config table, which syncs to every remote on push/pull", + issueops.ErrValidation, key, key) + } // The prefix is owned by bd init --prefix, bd bootstrap and bd // rename-prefix. Refused HERE rather than at the front door because `bd // config set` is not the only door that reaches this plane: before this diff --git a/internal/workapi/workspaceconfig_test.go b/internal/workapi/workspaceconfig_test.go index 3cef62b5c..816b621a5 100644 --- a/internal/workapi/workspaceconfig_test.go +++ b/internal/workapi/workspaceconfig_test.go @@ -57,6 +57,37 @@ func TestValidateSettingWriteRefusesTheProtectedKeyInBothSpellings(t *testing.T) } } +// TestValidateSettingWriteRefusesYamlOnlyKeys pins GH#7559: `bd config set` +// already refuses a YamlOnlyKey write via config.IsYamlOnlyKey at its own +// door, but this plane's HTTP settings surface (bd serve and its dashboard, +// PUT /v0/beads/config/{key}) had no such rule, so a tracker secret +// (github.token, linear.api_key, jira.api_token, gitlab.token, ado.pat) sent +// through it landed as a plain row in the Dolt config table — a SYNCED +// table, replicated to every remote on the next bd dolt push/pull. The +// PoC's five secret keys, plus a non-secret YamlOnlyKey (the exact GH#536 +// shape the map exists to prevent: a write that reports success but no +// reader ever consults), must all be refused here now. +func TestValidateSettingWriteRefusesYamlOnlyKeys(t *testing.T) { + for _, key := range []string{ + // The PoC's five secrets. + "github.token", "linear.api_key", "jira.api_token", "gitlab.token", "ado.pat", + // A non-secret YamlOnlyKey: the rule is "this plane is the database, + // these settings are not database settings", not "secrets only". + "no-db", + } { + _, err := ValidateSettingWrite(key, "SECRET-OR-SETTING-VALUE") + if !errors.Is(err, issueops.ErrValidation) { + t.Fatalf("ValidateSettingWrite(%q) error = %v, want ErrValidation", key, err) + } + if strings.Contains(err.Error(), "SECRET-OR-SETTING-VALUE") { + t.Errorf("ValidateSettingWrite(%q) error echoes the value %v; a secret must never appear in an error message", key, err) + } + if !strings.Contains(err.Error(), "config.yaml") { + t.Errorf("ValidateSettingWrite(%q) message %q does not point the caller at config.yaml", key, err) + } + } +} + func TestValidateSettingWriteParsesTheCustomStatusValue(t *testing.T) { for _, value := range []string{ "awaiting_review",