mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-17 21:50:53 +08:00
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.
158 lines
5.2 KiB
Go
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}
|
|
}
|