Compare commits

..
Author SHA1 Message Date
BaaRai 69831f5cdf fix(security): apply New options so the secret scrub actually runs
New accepted opts ...Option but never called them, so scrubSecrets stayed
false in the binary and ScrubSecretEnv was unreachable: the protection merged
in #136 never engaged. The unit test passed because it called the scrub
function directly instead of going through New.

Apply the options in the constructor and add a test that builds a Server
through New with WithSecretScrub and asserts the secrets are gone. Verified to
fail without the loop.
2026-11-03 23:47:49 +01:00
6 changed files with 54 additions and 78 deletions
+1 -5
View File
@@ -88,11 +88,7 @@ func run() int {
} }
defer mgr.Close() defer mgr.Close()
skillDir, err := config.SkillDir() skillDir := config.SkillDir()
if err != nil {
log.Printf("[config] %v", err)
return 1
}
if abs, err := filepath.Abs(skillDir); err == nil { if abs, err := filepath.Abs(skillDir); err == nil {
skillDir = abs skillDir = abs
} }
+13 -32
View File
@@ -4,9 +4,7 @@ package config
import ( import (
"encoding/json" "encoding/json"
"errors"
"fmt" "fmt"
"io/fs"
"net/url" "net/url"
"os" "os"
"path/filepath" "path/filepath"
@@ -98,23 +96,16 @@ func Path() string {
return candidates[0] return candidates[0]
} }
// Load reads and parses the config file. A missing file yields a zero Config (so // Load reads and parses the config file. A missing/unreadable file yields a zero
// callers fall back to defaults). A file that exists but cannot be read or parsed // Config (so callers fall back to defaults) rather than an error.
// is an error: ignoring it would run with defaults the operator did not choose. func Load() Config {
func Load() (Config, error) {
var c Config var c Config
path := Path() b, err := os.ReadFile(Path())
b, err := os.ReadFile(path)
if errors.Is(err, fs.ErrNotExist) {
return c, nil
}
if err != nil { if err != nil {
return c, fmt.Errorf("read config file %s: %w", path, err) return c
} }
if err := json.Unmarshal(b, &c); err != nil { _ = json.Unmarshal(b, &c)
return Config{}, fmt.Errorf("parse config file %s: %w", path, err) return c
}
return c, nil
} }
// SkillDir returns the skill root directory with precedence: // SkillDir returns the skill root directory with precedence:
@@ -122,23 +113,17 @@ func Load() (Config, error) {
// env ARTEX_SKILL_DIR > config file (skill_dir) > BaseDir()/skills // env ARTEX_SKILL_DIR > config file (skill_dir) > BaseDir()/skills
// //
// The directory is created if it does not exist. // The directory is created if it does not exist.
func SkillDir() (string, error) { func SkillDir() string {
var d string var d string
if v := strings.TrimSpace(os.Getenv("ARTEX_SKILL_DIR")); v != "" { if v := strings.TrimSpace(os.Getenv("ARTEX_SKILL_DIR")); v != "" {
d = v d = v
} else if v := strings.TrimSpace(Load().SkillDir); v != "" {
d = v
} else { } else {
c, err := Load() d = filepath.Join(BaseDir(), "skills")
if err != nil {
return "", err
}
if v := strings.TrimSpace(c.SkillDir); v != "" {
d = v
} else {
d = filepath.Join(BaseDir(), "skills")
}
} }
_ = os.MkdirAll(d, 0o755) _ = os.MkdirAll(d, 0o755)
return d, nil return d
} }
// PostgresDSN resolves the connection string with precedence: // PostgresDSN resolves the connection string with precedence:
@@ -153,11 +138,7 @@ func PostgresDSN() (dsn, source string, err error) {
if v := strings.TrimSpace(os.Getenv("ARTEX_PG_DSN")); v != "" { if v := strings.TrimSpace(os.Getenv("ARTEX_PG_DSN")); v != "" {
return v, "environment variable ARTEX_PG_DSN", nil return v, "environment variable ARTEX_PG_DSN", nil
} }
c, err := Load() db := Load().Database
if err != nil {
return "", "", err
}
db := c.Database
if d := strings.TrimSpace(db.DSN); d != "" { if d := strings.TrimSpace(db.DSN); d != "" {
return d, "config file " + Path() + " (database.dsn)", nil return d, "config file " + Path() + " (database.dsn)", nil
} }
-22
View File
@@ -3,7 +3,6 @@ package config
import ( import (
"os" "os"
"path/filepath" "path/filepath"
"strings"
"testing" "testing"
) )
@@ -41,24 +40,3 @@ func TestPostgresDSNPrecedence(t *testing.T) {
t.Fatalf("file dsn verbatim, got %q err %v", got, err) t.Fatalf("file dsn verbatim, got %q err %v", got, err)
} }
} }
// A config file that exists but is not valid JSON must fail loudly, not run with
// defaults (or report "no database config") as if the file were absent.
func TestMalformedConfigIsAnError(t *testing.T) {
cfgPath := filepath.Join(t.TempDir(), "config.json")
// What install.sh used to write for a password containing a double quote.
os.WriteFile(cfgPath, []byte(`{"database":{"host":"h","password":"a"b","dbname":"d"},"skill_dir":"/s"}`), 0o644)
t.Setenv("ARTEX_CONFIG", cfgPath)
t.Setenv("ARTEX_PG_DSN", "")
t.Setenv("ARTEX_SKILL_DIR", "")
if _, _, err := PostgresDSN(); err == nil || !strings.Contains(err.Error(), "parse config file") {
t.Fatalf("PostgresDSN: want a parse error, got %v", err)
}
if d, err := SkillDir(); err == nil {
t.Fatalf("SkillDir: want a parse error, got dir %q", d)
}
if _, err := Load(); err == nil {
t.Fatal("Load: want a parse error")
}
}
+8 -19
View File
@@ -9,16 +9,6 @@ warn(){ printf '\033[33m[!]\033[0m %s\n' "$*"; }
die(){ printf '\033[31m[x]\033[0m %s\n' "$*" >&2; exit 1; } die(){ printf '\033[31m[x]\033[0m %s\n' "$*" >&2; exit 1; }
ask(){ local p="$1" d="${2:-}" a; read -rp "$p${d:+ [$d]}: " a; echo "${a:-$d}"; } ask(){ local p="$1" d="${2:-}" a; read -rp "$p${d:+ [$d]}: " a; echo "${a:-$d}"; }
rand(){ head -c 18 /dev/urandom | base64 | tr -dc 'A-Za-z0-9' | head -c 24; } rand(){ head -c 18 /dev/urandom | base64 | tr -dc 'A-Za-z0-9' | head -c 24; }
# json_str prints $1 as a JSON string literal: backslash, double quote and the
# control characters read -r can return are escaped.
json_str(){
local s="$1"
s="${s//\\/\\\\}"; s="${s//\"/\\\"}"
s="${s//$'\t'/\\t}"; s="${s//$'\r'/\\r}"
printf '"%s"' "$s"
}
# sed_repl escapes $1 for the replacement side of s|...|...|: \, | and &.
sed_repl(){ printf '%s' "$1" | sed 's/[\\|&]/\\&/g'; }
# ── docker environment check / auto-install ─────────────────── # ── docker environment check / auto-install ───────────────────
ensure_docker(){ ensure_docker(){
@@ -48,8 +38,8 @@ install_docker(){
local pw key local pw key
pw="$(ask 'Postgres password (press Enter to generate randomly)' "$(rand)")" pw="$(ask 'Postgres password (press Enter to generate randomly)' "$(rand)")"
key="$(ask 'ANTHROPIC_API_KEY (may be empty, configure later in the UI)' '')" key="$(ask 'ANTHROPIC_API_KEY (may be empty, configure later in the UI)' '')"
sed -i.bak "s|^POSTGRES_PASSWORD=.*|POSTGRES_PASSWORD=$(sed_repl "$pw")|" .env sed -i.bak "s|^POSTGRES_PASSWORD=.*|POSTGRES_PASSWORD=${pw}|" .env
sed -i.bak "s|^ANTHROPIC_API_KEY=.*|ANTHROPIC_API_KEY=$(sed_repl "$key")|" .env sed -i.bak "s|^ANTHROPIC_API_KEY=.*|ANTHROPIC_API_KEY=${key}|" .env
rm -f .env.bak rm -f .env.bak
ok ".env generated (POSTGRES_PASSWORD set)" ok ".env generated (POSTGRES_PASSWORD set)"
else else
@@ -86,17 +76,16 @@ install_local(){
DB_SSL="$(ask 'sslmode (disable/require)' disable)" ;; DB_SSL="$(ask 'sslmode (disable/require)' disable)" ;;
esac esac
# generate config.json (string values JSON-escaped: a password may contain " or \) # generate config.json
case "$DB_PORT" in (*[!0-9]*|'') die "port must be a number: $DB_PORT" ;; esac
cat > config.json <<JSON cat > config.json <<JSON
{ {
"database": { "database": {
"host": $(json_str "$DB_HOST"), "host": "${DB_HOST}",
"port": ${DB_PORT}, "port": ${DB_PORT},
"user": $(json_str "$DB_USER"), "user": "${DB_USER}",
"password": $(json_str "$DB_PASS"), "password": "${DB_PASS}",
"dbname": $(json_str "$DB_NAME"), "dbname": "${DB_NAME}",
"sslmode": $(json_str "$DB_SSL") "sslmode": "${DB_SSL}"
} }
} }
JSON JSON
+29
View File
@@ -1,6 +1,8 @@
package server package server
import ( import (
"context"
"os"
"os/exec" "os/exec"
"strings" "strings"
"testing" "testing"
@@ -34,3 +36,30 @@ func TestScrubSecretEnvHidesSecretsFromChildren(t *testing.T) {
t.Errorf("non-secret variable did not reach the child process") t.Errorf("non-secret variable did not reach the child process")
} }
} }
// New must apply the options it receives. An earlier version accepted
// ...Option and never called them, so the binary kept the secrets in the
// environment while the unit test above still passed.
func TestNewAppliesSecretScrubOption(t *testing.T) {
// t.Setenv restores both after the test: the scrub unsets them for the rest
// of this process, and later tests still need the DSN.
if dsn := os.Getenv("ARTEX_PG_DSN"); dsn != "" {
t.Setenv("ARTEX_PG_DSN", dsn)
}
t.Setenv("ANTHROPIC_API_KEY", "scrub-probe")
t.Setenv("OPENAI_API_KEY", "scrub-probe")
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("no manager: %v", err)
}
t.Cleanup(func() { m.Close() })
ctx, cancel := context.WithCancel(context.Background())
cancel()
_ = New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir(), WithSecretScrub())
if os.Getenv("ANTHROPIC_API_KEY") != "" || os.Getenv("OPENAI_API_KEY") != "" {
t.Fatal("New did not apply WithSecretScrub: the secrets are still in the environment")
}
}
+3
View File
@@ -156,6 +156,9 @@ func New(ctx context.Context, m *Manager, skillDir string, dataDir string, keyDi
profChatAgents: map[int64]*agent.ChatAgent{}, profChatAgents: map[int64]*agent.ChatAgent{},
provByProfile: map[int64]*provEntry{}, llmHealth: newLLMHealthRegistry(m.pg), provByProfile: map[int64]*provEntry{}, llmHealth: newLLMHealthRegistry(m.pg),
taskAgents: map[string]*taskAgentBundle{}, archiveWake: make(chan struct{}, 1)} taskAgents: map[string]*taskAgentBundle{}, archiveWake: make(chan struct{}, 1)}
for _, o := range opts {
o(s)
}
s.initSetupToken() s.initSetupToken()
s.initSideQuestions() s.initSideQuestions()
// Circuit-breaker thresholds/cooldowns are hot parameters on the failure path; push the global retry policy to the Registry once at startup, // Circuit-breaker thresholds/cooldowns are hot parameters on the failure path; push the global retry policy to the Registry once at startup,