Files
ARTEX/intercept/risk.go
T
BaaRai 8f5a67d10c fix(intercept): destructive commands score high; chunk batch decisions to the server limit
The destructive shell signal is worth 60 instead of 50, so a destructive command alone scores 10 + 60 = 70, high. The level thresholds are unchanged. The approvals page sends the selection in sequential calls of at most 100 ids, the server limit (maxBatchDecide), instead of one call that the server would refuse with 400 when more than 100 rows are selected. If a call fails, sending stops: its ids and the later ones stay selected with the error, and ids already decided stay decided. The final toast gives the totals.
2026-11-14 22:46:18 +01:00

158 lines
5.2 KiB
Go

package intercept
import (
"encoding/json"
"regexp"
"strings"
)
// RiskReport is a deterministic estimate of how dangerous a pending tool call
// is. No model is involved, and it is computed when a pending row is read,
// never stored: changing the rules below re-scores every open request.
type RiskReport struct {
Score int `json:"score"` // 0..100
Level string `json:"level"` // low (<30) | medium (30..69) | high (>=70)
Reasons []string `json:"reasons"` // one per matched signal, in table order
}
const (
riskMediumAt = 30
riskHighAt = 70
riskMax = 100
)
func riskLevel(score int) string {
switch {
case score >= riskHighAt:
return "high"
case score >= riskMediumAt:
return "medium"
}
return "low"
}
type riskSignal struct {
reason string
points int
match func(string) bool
}
func reSignal(reason string, points int, pattern string) riskSignal {
re := regexp.MustCompile(pattern)
return riskSignal{reason, points, re.MatchString}
}
// shellBase is the score of a shell command that matches no signal.
const shellBase = 10
// shellSignals are additive; each counts once, and reasons follow this order.
var shellSignals = []riskSignal{
// 60 so that a destructive command alone reaches high: 10 + 60 = 70.
reSignal("destructive command (rm -r, dd, mkfs, shred, truncate, DROP TABLE, DELETE FROM, shutdown)", 60,
`(?i)\brm\s+([^;&|]*\s)?(-[a-z]*r[a-z]*|--recursive)(\s|$)|\bdd\s+[^;&|]*\b(if|of)=|\bmkfs\b|\bshred\b|\btruncate\b|\bdrop\s+table\b|\bdelete\s+from\b|\bshutdown\b`),
reSignal("privilege change (sudo, su, chmod 777, setcap)", 40,
`(^|[\s;&|(])(sudo|su)(\s|$)|\bchmod\s+(-\w+\s+)*0?777\b|\bsetcap\b`),
reSignal("reads secrets (/etc/shadow, .ssh, .aws/credentials, .git-credentials)", 40,
`/etc/shadow|\.ssh/|\.aws/credentials|\.git-credentials`),
reSignal("possible exfiltration (curl upload, scp, remote rsync, nc, socat)", 40,
`\bcurl\b[^;&|]*\s(-d|--data[\w-]*|-F|--form|-T|--upload-file)(\s|=|$)|\bscp\b|\brsync\b[^;&|]*\s\S+:|\bnc\b|\bncat\b|\bsocat\b`),
reSignal("reverse shell pattern (/dev/tcp, nc -e)", 60,
`/dev/tcp/|\b(nc|ncat)\b[^;&|]*\s-e(\s|$)`),
reSignal("network scanner (nmap, nuclei, sqlmap, ffuf, hydra, masscan, dalfox)", 30,
`\b(nmap|nuclei|sqlmap|ffuf|hydra|masscan|dalfox)\b`),
{"writes files (redirection or tee)", 15, writesFile},
}
var teeRE = regexp.MustCompile(`(^|[|;&]\s*)tee\b`)
// writesFile reports an output redirection to a file, or tee. "2>&1" and
// redirections to /dev/null are not writes.
func writesFile(cmd string) bool {
if teeRE.MatchString(cmd) {
return true
}
for i := 0; i < len(cmd); i++ {
if cmd[i] != '>' {
continue
}
rest := strings.TrimLeft(strings.TrimPrefix(cmd[i+1:], ">"), " \t")
if strings.HasPrefix(rest, "&") || strings.HasPrefix(rest, "/dev/null") || rest == "" {
continue
}
return true
}
return false
}
// fileBase is the score of a file write or edit; a sensitive path adds
// fileSensitive on top, which makes it high.
const (
fileBase = 30
fileSensitive = 40
)
var sensitivePathRE = regexp.MustCompile(`(^|/)(\.ssh|\.aws|\.gnupg)/|^/etc/|^/root/|^/boot/|/\.git-credentials$|/\.(bashrc|bash_profile|profile|zshrc)$|/authorized_keys$|(^|/)\.env$`)
// webBase is the score of a web read; a mutating method adds webMutating.
const (
webBase = 10
webMutating = 30
)
// unknownBase is the floor for MCP tools, unrecognized tools and unreadable
// input: medium, never low.
const unknownBase = 30
// ScoreRisk scores one tool call. It never panics on malformed input: input
// that is not a JSON object scores medium with a reason.
func ScoreRisk(tool string, input json.RawMessage) RiskReport {
var fields map[string]any
if err := json.Unmarshal(input, &fields); err != nil || fields == nil {
return riskReport(unknownBase, []string{"tool input is not a valid JSON object"})
}
str := func(keys ...string) string {
for _, k := range keys {
if v, ok := fields[k].(string); ok && v != "" {
return v
}
}
return ""
}
switch tool {
case "Bash", "shell_open", "Monitor", "shell_send":
cmd := str("command", "text")
score, reasons := shellBase, []string{}
for _, s := range shellSignals {
if s.match(cmd) {
score += s.points
reasons = append(reasons, s.reason)
}
}
return riskReport(score, reasons)
case "Write", "Edit", "MultiEdit", "NotebookEdit":
reasons := []string{"writes or edits a file"}
score := fileBase
if sensitivePathRE.MatchString(str("file_path", "path", "notebook_path")) {
score += fileSensitive
reasons = append(reasons, "sensitive path (system, credential or shell startup file)")
}
return riskReport(score, reasons)
case "WebFetch", "web_search":
method := strings.ToUpper(str("method"))
switch method {
case "POST", "PUT", "PATCH", "DELETE":
return riskReport(webBase+webMutating, []string{"mutating HTTP method " + method})
}
return riskReport(webBase, []string{})
}
if strings.HasPrefix(tool, "mcp__") {
return riskReport(unknownBase, []string{"MCP tool: no specific rules"})
}
return riskReport(unknownBase, []string{"unrecognized tool: no specific rules"})
}
func riskReport(score int, reasons []string) RiskReport {
score = min(score, riskMax)
return RiskReport{Score: score, Level: riskLevel(score), Reasons: reasons}
}