Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

9.2 KB
Raw Blame
package redact

import (
	"regexp"
	"strings"
	"unicode"
)

// What follows a secret's name and a colon or = is not always the secret.
// The SECRET rules take a name with password, secret, token or api_key in
// it, then : or =, then the value; a prompt and a session's code have that
// shape where nothing is secret:
//
//   - a place in a file: internal/auth/token.go:L643-669. names lines
//     643 to 669 of token.go (AlpsNowX on X, 10-28). It went to the model
//     as {{SECRET_…}}, and as a value masked once, everywhere it came
//     again (L643-669. alone in the next prompt): the agent could no longer
//     read the lines it was pointed at. The name is a file's, not a field's.
//   - a file's or a folder's path: PRIVATE_KEY_PATH=~/.ssh/id_ed25519,
//     "credentials": "/Users/…/legacy_credentials/x7k2/adc.json" name where
//     a secret is kept, and the agent needs the path as written to read it
//     (AkinoNya on X, 10-28: folders and skills with a random string in
//     their name were replaced).
//   - code naming a secret: access_token = get_access_token_v2,
//     max_tokens=max_tokens_v3, secret: env.SECRET_V2 (binary4cat on X,
//     10-28: function names were masked). A key's characters are random;
//     a name made of words, one of them token, secret or password, is a
//     function's or a variable's.
//   - a package's version: a dependency whose name has token, secret or
//     password in it is pinned in a manifest the same way, "js-tokens":
//     "^4.0.0-beta.1", jsonwebtoken = "9.2.0-beta1", tokenizer =
//     "2.4.0-beta02" (dniray on Discord, v0.1.1917: package names and
//     their versions were replaced). A release's version is published for
//     anyone to read (versionValue).
//
// A secret written down still masks: password=hunter2pass9,
// API_KEY=AbC123dEf456GhI789, token: t0k3nValue2, a password of one word
// and digits (Passw0rd123, password123).

// fieldAt is where a value the SECRET rules found can be a secret: not
// code (notCode), and not a place in a file, a path or a name in code.
func fieldAt(s string, a, b int) bool {
	if !notCode(s, a, b) {
		return false
	}
	v := s[a:b]
	if v[0] == '=' {
		return false // Go's := with no space after it: secretKey:=base64Encode(raw)
	}
	return !fileField(s, a) && !lineRef(v) && !pathValue(v) && !namesASecret(v) && !skillName(s, a, b) && !versionValue(v)
}

// versionRangeRe is a release's version as a manifest or a lock file
// pins it: a range's operator (^, ~, >=, ==), numbers joined by dots,
// then a pre-release's or a build's parts, each a word releases are
// tagged with and its number (-beta.1, -rc1, -alpha03, .post2, b1,
// .RELEASE, +build.5) or a number alone. One letter on its own is a
// part only with a number after it (b1, M2), so 3.14159abc is no
// version.
var versionRangeRe = regexp.MustCompile(`^(?:[~^]|[<>=!~]=?|==)?[vV]?\d+(?:\.\d+)+` +
	`(?:[-+._]?(?:(?i:alpha|beta|rc|pre|preview|post|dev|canary|next|nightly|snapshot|release|final|ga|stable|build|incubating)\d*|[abcmABCM]\d+|\d+))*$`)

// versionValue says v is a release's version, which no secret is: the
// SECRET rules found it after a package's name with token or secret in
// it, the local model in a manifest.
func versionValue(v string) bool { return versionRangeRe.MatchString(v) }

// skillName says s[a:b] is the second half of plugin:skill, as Claude
// Code names a plugin's skill and command (design-tokens:generate-v2,
// secret-scan:audit-x7k2p9q1): words in lower case joined by hyphens on
// both sides of a colon with no space around it. A key has a capital or
// a long random run (notASlug).
func skillName(s string, a, b int) bool {
	if a < 2 || s[a-1] != ':' || !skillSlugRe.MatchString(s[a:b]) || notASlug(s[a:b]) {
		return false
	}
	i := a - 1
	for i > 0 && strings.IndexByte("abcdefghijklmnopqrstuvwxyz0123456789-", s[i-1]) >= 0 {
		i--
	}
	return i < a-1 && (i == 0 || strings.IndexByte(alnum+"_.", s[i-1]) < 0) && skillSlugRe.MatchString(s[i:a-1])
}

// skillSlugRe is words in lower case joined by hyphens: a plugin's, a skill's
// or a command's name.
var skillSlugRe = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)+$`)

// lineRefRe is a line or a range of lines, as an editor or a review names
// them: L643, L643-669, L12-L40, 643-669, 643:12, with a sentence's
// stop after it.
var lineRefRe = regexp.MustCompile(`^L?\d+(?:[-–:]L?\d+)*[.,;:]?$`)

// lineRef says v is a line or a range of lines, never a secret.
func lineRef(v string) bool { return lineRefRe.MatchString(v) }

// fileField says the name before the value at s[a] is a file's, or a
// path's last part, not a field's: token.go:L643-669, src/secret_store.ts:…,
// skills/secret-scanner:…. It reads back over the separator (: or =, and
// the quotes and spaces around it) to the name.
func fileField(s string, a int) bool {
	i := a
	for i > 0 && strings.IndexByte(" \t\"'\\", s[i-1]) >= 0 {
		i--
	}
	if i == 0 || s[i-1] != ':' && s[i-1] != '=' {
		return false
	}
	i--
	for i > 0 && strings.IndexByte(" \t\"'\\", s[i-1]) >= 0 {
		i--
	}
	end := i
	for i > 0 && strings.IndexByte(alnum+"_.-", s[i-1]) >= 0 {
		i--
	}
	name := s[i:end]
	if name == "" {
		return false
	}
	if i > 0 && (s[i-1] == '/' || s[i-1] == '\\') {
		return true // a path's last part
	}
	dot := strings.LastIndexByte(name, '.')
	return dot > 0 && sourceExt[strings.ToLower(name[dot+1:])]
}

// sourceExt are the extensions of files an agent reads and names with a
// line after them: code, docs and configs. Not .env, .txt, .key or .pem,
// whose content is what a secret is kept in.
var sourceExt = map[string]bool{
	"go": true, "ts": true, "tsx": true, "mts": true, "cts": true, "js": true, "jsx": true, "mjs": true, "cjs": true,
	"py": true, "pyi": true, "rb": true, "rs": true, "java": true, "kt": true, "kts": true, "swift": true,
	"c": true, "h": true, "cc": true, "cpp": true, "cxx": true, "hpp": true, "hh": true, "m": true, "mm": true,
	"cs": true, "fs": true, "php": true, "scala": true, "dart": true, "lua": true, "zig": true, "nim": true,
	"ex": true, "exs": true, "erl": true, "hs": true, "ml": true, "clj": true, "r": true, "jl": true,
	"sh": true, "bash": true, "zsh": true, "fish": true, "ps1": true, "vue": true, "svelte": true, "astro": true,
	"md": true, "mdx": true, "rst": true, "sql": true, "proto": true, "graphql": true, "gradle": true,
	"html": true, "css": true, "scss": true, "less": true, "json": true, "jsonc": true, "yaml": true, "yml": true,
	"toml": true, "xml": true, "tf": true, "ipynb": true,
}

// pathRoots are the folders an absolute path starts at.
var pathRoots = []string{
	"Users", "home", "tmp", "private", "var", "etc", "run", "opt", "usr", "mnt", "Volumes", "root", "srv",
	"data", "workspace", "workspaces", "app", "Applications", "Library", "System", "proc", "dev", "sys", "nix",
}

// pathValue says v is a file's or a folder's path: one from home (~/),
// from here (./, ../), or from a root folder (/Users/…, /tmp/…), with no
// + or = in it as base64 has.
func pathValue(v string) bool {
	if strings.ContainsAny(v, "+=") {
		return false
	}
	for _, p := range []string{"~/", "./", "../"} {
		if strings.HasPrefix(v, p) && len(v) > len(p) {
			return true
		}
	}
	if !strings.HasPrefix(v, "/") {
		return false
	}
	first, rest, ok := strings.Cut(v[1:], "/")
	if !ok || rest == "" {
		return false
	}
	for _, r := range pathRoots {
		if first == r {
			return true
		}
	}
	return false
}

// secretWords are the words of a name in code that say it holds a secret.
var secretWords = map[string]bool{
	"token": true, "tokens": true, "secret": true, "secrets": true, "password": true, "passwords": true,
	"passwd": true, "pwd": true, "key": true, "keys": true, "apikey": true, "credential": true, "credentials": true,
}

// identRe is a name in code, read through others or not: camelCase,
// snake_case, SCREAMING_CASE, env.SECRET_V2.
var identRe = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$`)

// namesASecret says v is a name in code for a secret, not one: two words
// or more, one of them token, secret, password or key, written as code
// writes a name: starting in lower case, or with _ or . between its
// words. refreshToken2, generate_token_v2, env.SECRET_V2 and
// countTokens4o are names; Passw0rd123 and password123 are one word, and
// SuperSecret2024 is a password, not how code names a value.
func namesASecret(v string) bool {
	if !identRe.MatchString(v) {
		return false
	}
	if !unicode.IsLower(rune(v[0])) && !strings.ContainsAny(v, "_.") {
		return false
	}
	words, named := 0, false
	for _, w := range identWords(v) {
		if strings.IndexFunc(w, unicode.IsLetter) < 0 {
			continue
		}
		words++
		if i := strings.IndexAny(w, digits); i >= 0 {
			w = w[:i] // countTokens4o: Tokens
		}
		if secretWords[strings.ToLower(w)] {
			named = true
		}
	}
	return words >= 2 && named
}

// identWords are v's words: split at _ and ., and where a capital starts
// a word in camelCase (refreshToken2 is refresh and Token2).
func identWords(v string) []string {
	var out []string
	for _, part := range strings.FieldsFunc(v, func(r rune) bool { return r == '_' || r == '.' }) {
		start := 0
		for i := 1; i < len(part); i++ {
			if part[i] >= 'A' && part[i] <= 'Z' && part[i-1] >= 'a' && part[i-1] <= 'z' {
				out = append(out, part[start:i])
				start = i
			}
		}
		out = append(out, part[start:])
	}
	return out
}