Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
redact: words in lower case the model took for a secret go as written unless assigned to a secret's name (dniray on Discord)
yetoneb9f1fcddde03
diff --git a/internal/redact/known.go b/internal/redact/known.goindex 333e2f8e7..f57f3f0ab 100644--- a/internal/redact/known.go+++ b/internal/redact/known.go@@ -199,9 +199,16 @@ func knownSpans(s string, o Options) []span {if !o.coversKind(k.kind) {continue}- if sc, ok := scores[k.v]; ok && sc < o.MinScore {+ sc, scored := scores[k.v]+ if scored && sc < o.MinScore {continue // the model's alone, under the slider}+ if scored && sc < ruleFound && k.kind == "SECRET" && wordsOnly(k.v) && !assignedSecret(s, i) {+ // words the model alone took for a secret, as modelFits+ // lets go now: what a magpie before it had remembered+ // (drizzle-orm, dniray on Discord, v0.1.1976)+ continue+ }if best != nil && len(k.v) <= len(best.v) || !strings.HasPrefix(s[i:], k.v) || !standsAlone(k.kind, s, i, i+len(k.v)) {continue}diff --git a/internal/redact/model.go b/internal/redact/model.goindex 9bc6f30dc..2c7862970 100644--- a/internal/redact/model.go+++ b/internal/redact/model.go@@ -2,6 +2,7 @@ package redactimport ("regexp"+ "slices""strings""unicode""unicode/utf8"@@ -359,6 +360,9 @@ func modelFits(s string, a, b int, kind string) bool {if pinnedAfter(s, b) {return false}+ if wordsOnly(v) && !assignedSecret(s, a) {+ return false+ }return !hexRe.MatchString(v) || secretCued(s, a)case "EMAIL":// a URL's user:password@host is no address, as for the rule's (#3538)@@ -367,6 +371,49 @@ func modelFits(s string, a, b int, kind string) bool {return true}+// wordsOnlyRe is words in lower case and nothing else, joined by - . or+// _: drizzle-orm, reflect-metadata, lodash.merge, secretstorage.+var wordsOnlyRe = regexp.MustCompile(`^[a-z]+(?:[-._][a-z]+)*$`)++// wordsOnly says v, which the model took for a secret, is made of words+// in lower case alone, as a package's, a tool's or a setting's name is.+// A key is random: it has a digit, a capital or a symbol in it, and the+// SECRET rules ask a digit of a value after password= too (secretValue).+// AstrLink Guard took drizzle-orm for a secret in a tsup config's+// external list in a Markdown fence (dniray on Discord, v0.1.1976; 0.515+// on that line alone), after v0.1.1932 and v0.1.1976 had each let it go+// in more places (an import, package.json, a tsc error): the places a+// package's name is written can't all be listed, so the shape decides. Such a value is a+// secret only where it is assigned to a secret's name (assignedSecret):+// PASSWORD=opensesame, "password": "letmeinplease", the wifi password is+// purplemonkey.+func wordsOnly(v string) bool { return wordsOnlyRe.MatchString(v) }++// assignedSecret says the value at s[a] is given to a secret's name: the+// name, then =, :, is or 是 (and the quotes around them), right before it.+// A list's comma before it is no assignment, whatever is further back:+// 'jsonwebtoken', 'drizzle-orm' (secretCued takes the token in that).+func assignedSecret(s string, a int) bool {+ before := strings.ToLower(strings.TrimRight(s[max(0, a-64):a], " \t\"'`“「"))+ for _, sep := range []string{"=", ":", ":", " is", " was", "是", "为", "為"} {+ if !strings.HasSuffix(before, sep) {+ continue+ }+ name := strings.TrimRight(before[:len(before)-len(sep)], " \t\"'`:")+ i := len(name)+ for i > 0 && (wordByte(name[i-1]) || name[i-1] == '.' || name[i-1] == '-') {+ i--+ }+ if i == len(name) {+ // a Chinese name: 密码是, 令牌为+ return slices.ContainsFunc(secretCues, func(c string) bool { return c[0] >= 0x80 && strings.HasSuffix(name, c) })+ }+ return slices.ContainsFunc(secretCues, func(c string) bool { return c[0] < 0x80 && strings.Contains(name[i:], c) }) ||+ strings.Contains(name[i:], "pass") || strings.Contains(name[i:], "pwd") || strings.Contains(name[i:], "credential")+ }+ return false+}+// pinnedAfter says the value that ends at s[b] is a package's name, as// a requirement pins its version after it: django-rest-passwordreset==1.4.0,// tokenizers>=0.15, a-lib~=2.1 (pip's comparisons). AstrLink Guard took adiff --git a/internal/redact/package_words_test.go b/internal/redact/package_words_test.gonew file mode 100644index 000000000..f4bf75cc2--- /dev/null+++ b/internal/redact/package_words_test.go@@ -0,0 +1,119 @@+package redact++import (+ "encoding/json"+ "strings"+ "testing"+)++// dniray on Discord, v0.1.1976 after 300b7eee0: drizzle-orm still went+// out as {{SECRET_o2tu7vej}}, now in a tsup config in a Markdown fence,+// where nothing says a package is loaded or pinned:+// external: [/@nestjs/, 'reflect-metadata', 'rxjs', 'mysql2', 'drizzle-orm'].+// The places a package's name is written can't all be listed. A value of+// words in lower case alone has no randomness for a key to be made of:+// the model's secret of that shape is a secret only where it is assigned+// to a password's, a token's or a key's name.+const dnirayBlock = "```ts\nexport default defineConfig({\n entry: ['src/main.ts'],\n format: [\n 'cjs',\n clean: true,\n noExternal: [/@nexus\\/shared/],\n external: [/@nestjs/, 'reflect-metadata', 'rxjs', 'mysql2', 'drizzle-orm'],\n sourcemap: true,\n})\n```\n"++// scoredModel finds each of values as a secret at a score, as the real+// models give one (a fake's 0 counts as a rule's find).+func scoredModel(values ...string) Model {+ f := &fakeModel{values: map[string]string{}}+ for _, v := range values {+ f.values[v] = "secret"+ }+ return func(texts []string) [][]Found {+ out := f.find(texts)+ for i := range out {+ for j := range out[i] {+ out[i][j].Score = 0.93+ }+ }+ return out+ }+}++func TestModelWordsArentSecrets(t *testing.T) {+ const line = " external: [/@nestjs/, 'reflect-metadata', 'rxjs', 'mysql2', 'drizzle-orm'],"+ o := Options{Secrets: true, Personal: true, Model: scoredModel("drizzle-orm", "reflect-metadata")}+ // in a user's message, as Markdown+ body, _ := json.Marshal(map[string]any{"model": "m", "messages": []any{+ map[string]any{"role": "user", "content": "tsup.config.ts:\n\n" + dnirayBlock + "\nwhy is drizzle-orm bundled?"},+ }})+ out, _ := MaskJSON(body, o)+ if s := string(out); strings.Contains(s, "{{SECRET_") || !strings.Contains(s, line) {+ t.Errorf("in a message: %s", out)+ }+ // in a Read's tool_result, with Claude Code's line numbers+ var read strings.Builder+ for i, l := range strings.Split(strings.TrimSuffix(dnirayBlock, "\n"), "\n") {+ read.WriteString(strings.Repeat(" ", 5) + string(rune('1'+i%9)) + "→" + l + "\n")+ }+ body, _ = json.Marshal(map[string]any{"model": "m", "messages": []any{+ map[string]any{"role": "assistant", "content": []any{map[string]any{"type": "tool_use", "id": "toolu_01", "name": "Read", "input": map[string]any{"file_path": "/w/docs/build.md"}}}},+ map[string]any{"role": "user", "content": []any{map[string]any{"type": "tool_result", "tool_use_id": "toolu_01", "content": read.String()}}},+ }})+ if out, _ := MaskJSON(body, o); strings.Contains(string(out), "{{SECRET_") {+ t.Errorf("in a tool_result: %s", out)+ }+ // prose and a name alone+ for _, s := range []string{"we keep drizzle-orm external", "drizzle-orm", "see reflect-metadata."} {+ if out, n := Mask(s, o); n != 0 {+ t.Errorf("%q: %q", s, out)+ }+ }+}++// A value the model took for a secret before this, remembered as known, is+// masked again only where it is assigned to a secret's name: what a user's+// running magpie had learned goes as written in the next request, the+// model finding nothing in it.+func TestKnownModelWordsGoAsWritten(t *testing.T) {+ // as an older magpie remembered it: masked as the model's, at its score+ p := placeholder("SECRET", "drizzle-orm")+ placeholder("SECRET", "reflect-metadata")+ for _, v := range []string{"drizzle-orm", "reflect-metadata"} {+ noteScores(v, []span{{0, len(v), "SECRET", ByModel, 0.93, false}})+ }+ o := Options{Secrets: true, Personal: true}+ if out, n := Mask(dnirayBlock, o); n != 0 || strings.Contains(out, p) {+ t.Errorf("as known: %q", out)+ }+ body, _ := json.Marshal(map[string]any{"messages": []any{map[string]any{"role": "user", "content": "and now\n" + dnirayBlock}}})+ o.Model = scoredModel()+ if out, _ := MaskJSON(body, o); strings.Contains(string(out), "{{SECRET_") {+ t.Errorf("as known, in a body: %s", out)+ }+ // where it is assigned to a password, it is the password still+ if out, _ := Mask("DB_PASSWORD: drizzle-orm", o); strings.Contains(out, "drizzle-orm") {+ t.Errorf("assigned: %q", out)+ }+}++// What stays a secret: words the model finds where they are assigned to a+// secret's name, any value with a digit, a capital or a symbol in it, and+// whatever a rule found, words alone too, wherever it comes again.+func TestWordSecretsStillMasked(t *testing.T) {+ for _, c := range []struct{ text, value string }{+ {"PASSWORD=opensesame", "opensesame"},+ {"{\"password\": \"letmeinplease\"}", "letmeinplease"},+ {"the wifi password is purplemonkey", "purplemonkey"},+ {"api_key: correct-horse-battery", "correct-horse-battery"},+ {"login with hunter2pass", "hunter2pass"},+ {"use Zq8vR2mT6wLp to sign in", "Zq8vR2mT6wLp"},+ {"the code is Tr0ub4dor&3xq", "Tr0ub4dor&3xq"},+ } {+ o := Options{Secrets: true, Personal: true, Model: scoredModel(c.value)}+ if out, _ := Mask(c.text, o); strings.Contains(out, c.value) {+ t.Errorf("%q left in %q", c.value, out)+ }+ }+ // a rule's find of words is masked as known wherever it comes again+ if out, _ := Mask("token 是 bluewhalesinging", Options{Secrets: true}); strings.Contains(out, "bluewhalesinging") {+ t.Fatalf("not masked by the rule: %q", out)+ }+ if out, _ := Mask("I typed bluewhalesinging there", Options{Secrets: true}); strings.Contains(out, "bluewhalesinging") {+ t.Errorf("rule's known value left: %q", out)+ }+}