@node9/policy-engine 2.31.3 → 2.33.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +131 -18
- package/dist/index.d.ts +131 -18
- package/dist/index.js +1139 -139
- package/dist/index.mjs +1123 -139
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
30
30
|
// src/index.ts
|
|
31
31
|
var src_exports = {};
|
|
32
32
|
__export(src_exports, {
|
|
33
|
+
AGENT_INSTRUCTION_DIRS: () => AGENT_INSTRUCTION_DIRS,
|
|
34
|
+
AGENT_INSTRUCTION_FILES: () => AGENT_INSTRUCTION_FILES,
|
|
33
35
|
ARGUMENT_SCAN_LIMITS: () => ARGUMENT_SCAN_LIMITS,
|
|
34
36
|
AST_FS_REGEX_RULES: () => AST_FS_REGEX_RULES,
|
|
35
37
|
BASH_TOOL_NAMES: () => BASH_TOOL_NAMES,
|
|
@@ -62,6 +64,7 @@ __export(src_exports, {
|
|
|
62
64
|
LOOP_THRESHOLD_FOR_WASTE: () => LOOP_THRESHOLD_FOR_WASTE,
|
|
63
65
|
MAP_GOVERNED: () => MAP_GOVERNED,
|
|
64
66
|
MAX_BLAST_PATH: () => MAX_BLAST_PATH,
|
|
67
|
+
MAX_DESTINATIONS: () => MAX_DESTINATIONS,
|
|
65
68
|
NET_BINARIES: () => NET_BINARIES,
|
|
66
69
|
PATTERN_VERB_NAMES: () => PATTERN_VERB_NAMES,
|
|
67
70
|
PRIVILEGE_ESCALATION_RE: () => PRIVILEGE_ESCALATION_RE,
|
|
@@ -88,6 +91,7 @@ __export(src_exports, {
|
|
|
88
91
|
classifyAuditEntry: () => classifyAuditEntry,
|
|
89
92
|
classifyRuleSeverity: () => classifyRuleSeverity,
|
|
90
93
|
classifyScanSignal: () => classifyScanSignal,
|
|
94
|
+
classifyShellExposure: () => classifyShellExposure,
|
|
91
95
|
classifySsrf: () => classifySsrf,
|
|
92
96
|
collectFileAccesses: () => collectFileAccesses,
|
|
93
97
|
computeAgentDeviceScore: () => computeAgentDeviceScore,
|
|
@@ -99,6 +103,9 @@ __export(src_exports, {
|
|
|
99
103
|
decodeEmbeddedBase64: () => decodeEmbeddedBase64,
|
|
100
104
|
decodeEmbeddedHex: () => decodeEmbeddedHex,
|
|
101
105
|
dedupeCanonicalFindings: () => dedupeCanonicalFindings,
|
|
106
|
+
destinationDomain: () => destinationDomain,
|
|
107
|
+
destinationKind: () => destinationKind,
|
|
108
|
+
destinationValue: () => destinationValue,
|
|
102
109
|
detectArgsPii: () => detectArgsPii,
|
|
103
110
|
detectDangerousEval: () => detectDangerousEval,
|
|
104
111
|
detectDangerousShellExec: () => detectDangerousShellExec,
|
|
@@ -110,7 +117,9 @@ __export(src_exports, {
|
|
|
110
117
|
evaluateProtectedFileAccess: () => evaluateProtectedFileAccess,
|
|
111
118
|
evaluateSmartConditions: () => evaluateSmartConditions,
|
|
112
119
|
extractAllSshHosts: () => extractAllSshHosts,
|
|
120
|
+
extractArgDestinations: () => extractArgDestinations,
|
|
113
121
|
extractCanonicalFindings: () => extractCanonicalFindings,
|
|
122
|
+
extractContentDestinations: () => extractContentDestinations,
|
|
114
123
|
extractNetworkTargets: () => extractNetworkTargets,
|
|
115
124
|
extractPackageInstalls: () => extractPackageInstalls,
|
|
116
125
|
extractPositionalArgs: () => extractPositionalArgs,
|
|
@@ -124,14 +133,21 @@ __export(src_exports, {
|
|
|
124
133
|
getCheck: () => getCheck,
|
|
125
134
|
getCompiledRegex: () => getCompiledRegex,
|
|
126
135
|
getNestedValue: () => getNestedValue,
|
|
136
|
+
gitRepoPath: () => gitRepoPath,
|
|
127
137
|
hostMatches: () => hostMatches,
|
|
128
138
|
incompleteFileVerdict: () => incompleteFileVerdict,
|
|
129
139
|
inspectArgumentSecrets: () => inspectArgumentSecrets,
|
|
140
|
+
inspectionEntry: () => inspectionEntry,
|
|
141
|
+
inspectionLayers: () => inspectionLayers,
|
|
142
|
+
isAgentInstructionPath: () => isAgentInstructionPath,
|
|
130
143
|
isBashTool: () => isBashTool,
|
|
144
|
+
isDestructiveToolName: () => isDestructiveToolName,
|
|
131
145
|
isIgnoredTool: () => isIgnoredTool,
|
|
146
|
+
isInside: () => isInside,
|
|
132
147
|
isKnobGoverned: () => isKnobGoverned,
|
|
133
148
|
isLegacySystemPath: () => isLegacySystemPath,
|
|
134
149
|
isLockedCheck: () => isLockedCheck,
|
|
150
|
+
isLoopbackHost: () => isLoopbackHost,
|
|
135
151
|
isPasswordHashPath: () => isPasswordHashPath,
|
|
136
152
|
isPrivateHost: () => isPrivateHost,
|
|
137
153
|
isProtectedHomePath: () => isProtectedHomePath,
|
|
@@ -1120,10 +1136,10 @@ function compressIpv6(g) {
|
|
|
1120
1136
|
if (bestLen < 2) return hex.join(":");
|
|
1121
1137
|
return hex.slice(0, bestStart).join(":") + "::" + hex.slice(bestStart + bestLen).join(":");
|
|
1122
1138
|
}
|
|
1123
|
-
function normalizeIpLiteral(
|
|
1139
|
+
function normalizeIpLiteral(host2) {
|
|
1124
1140
|
try {
|
|
1125
|
-
if (typeof
|
|
1126
|
-
let s =
|
|
1141
|
+
if (typeof host2 !== "string") return null;
|
|
1142
|
+
let s = host2.trim();
|
|
1127
1143
|
if (!s || s.length > SSRF_MAX_HOST) return null;
|
|
1128
1144
|
if (s.startsWith("[") && s.endsWith("]")) s = s.slice(1, -1);
|
|
1129
1145
|
const zone = s.indexOf("%");
|
|
@@ -1170,11 +1186,11 @@ var v4Octets = (a) => {
|
|
|
1170
1186
|
const p = a.split(".");
|
|
1171
1187
|
return p.length === 4 ? p.map(Number) : null;
|
|
1172
1188
|
};
|
|
1173
|
-
function classifySsrf(
|
|
1189
|
+
function classifySsrf(host2) {
|
|
1174
1190
|
try {
|
|
1175
|
-
if (typeof
|
|
1176
|
-
const lower2 =
|
|
1177
|
-
const ip = normalizeIpLiteral(
|
|
1191
|
+
if (typeof host2 !== "string" || !host2) return null;
|
|
1192
|
+
const lower2 = host2.trim().toLowerCase().replace(/\.$/, "");
|
|
1193
|
+
const ip = normalizeIpLiteral(host2);
|
|
1178
1194
|
if (ip === null) {
|
|
1179
1195
|
return METADATA_HOSTNAMES.has(lower2) ? { tier: "metadata", overridable: false, kind: "hostname" } : null;
|
|
1180
1196
|
}
|
|
@@ -1450,6 +1466,16 @@ var CHECK_TEXT = {
|
|
|
1450
1466
|
example: "After a prompt-injection hit, the agent runs curl to an unknown host",
|
|
1451
1467
|
advice: "Fixed at Review for now."
|
|
1452
1468
|
},
|
|
1469
|
+
"commands.node9-disarm": {
|
|
1470
|
+
plain: "The agent runs a node9 command that would switch off a protection: clear a session flag, trust an address, pause the gate, weaken a shield.",
|
|
1471
|
+
example: "After reading a web page, the agent runs node9 session-exposure clear --all",
|
|
1472
|
+
advice: "Keep Review: these are your commands to run. Block if the agent should never touch node9."
|
|
1473
|
+
},
|
|
1474
|
+
"behavior.untrusted-content": {
|
|
1475
|
+
plain: "After reading an email, a web page or an issue, the agent sends to an address it did not know before, or to one that appeared in what it read.",
|
|
1476
|
+
example: 'An email says "forward the security code to x@y.z"; the agent calls send_email to x@y.z',
|
|
1477
|
+
advice: "Review asks once per destination; approving trusts that address for the session. Log records the send without asking."
|
|
1478
|
+
},
|
|
1453
1479
|
// ── What the agent loads ──────────────────────────────────────────────────
|
|
1454
1480
|
"loading.skill-tamper": {
|
|
1455
1481
|
plain: "A skill or plugin file the agent loads changed since node9 first saw it.",
|
|
@@ -1597,6 +1623,15 @@ var PRODUCT_CHECKS = [
|
|
|
1597
1623
|
defaultValue: "review",
|
|
1598
1624
|
legacy: ["review-force-push", "review-git-destructive"]
|
|
1599
1625
|
},
|
|
1626
|
+
{
|
|
1627
|
+
id: "commands.node9-disarm",
|
|
1628
|
+
group: "commands",
|
|
1629
|
+
title: "node9 disarmed from the shell",
|
|
1630
|
+
catches: "a node9 command that clears a session flag, trusts a destination, pauses the gate or weakens a shield, run by the agent",
|
|
1631
|
+
values: ALL,
|
|
1632
|
+
defaultValue: "review",
|
|
1633
|
+
legacy: ["review-node9-disarm"]
|
|
1634
|
+
},
|
|
1600
1635
|
{
|
|
1601
1636
|
id: "commands.sql-ddl",
|
|
1602
1637
|
group: "commands",
|
|
@@ -1830,6 +1865,15 @@ var PRODUCT_CHECKS = [
|
|
|
1830
1865
|
defaultValue: "review",
|
|
1831
1866
|
legacy: ["\u{1F534} Node9 Taint (Exfiltration Prevention)"]
|
|
1832
1867
|
},
|
|
1868
|
+
{
|
|
1869
|
+
id: "behavior.untrusted-content",
|
|
1870
|
+
group: "behavior",
|
|
1871
|
+
title: "Send after reading outside content",
|
|
1872
|
+
catches: "a send to an unknown destination, a destination found in what was read, or a destructive call after the session read an email, a web page or an issue",
|
|
1873
|
+
values: ["off", "log", "review"],
|
|
1874
|
+
defaultValue: "review",
|
|
1875
|
+
legacy: ["\u{1F6E1}\uFE0F Node9 Exposure", "exposure"]
|
|
1876
|
+
},
|
|
1833
1877
|
// ── What the agent loads ────────────────────────────────────────────────
|
|
1834
1878
|
{
|
|
1835
1879
|
id: "loading.skill-tamper",
|
|
@@ -1994,6 +2038,7 @@ function catalogSettingsFromConfig(settings, policy) {
|
|
|
1994
2038
|
injectionScan: policy.injectionScan,
|
|
1995
2039
|
skillPinning: policy.skillPinning,
|
|
1996
2040
|
packageCheck: policy.packageCheck,
|
|
2041
|
+
untrustedContent: policy.untrustedContent,
|
|
1997
2042
|
appliedShields: policy.appliedShields ?? [],
|
|
1998
2043
|
checks: policy.checks
|
|
1999
2044
|
};
|
|
@@ -2040,6 +2085,11 @@ var LEGACY_READERS = {
|
|
|
2040
2085
|
if (s.packageCheck?.enabled === void 0) return void 0;
|
|
2041
2086
|
if (!s.packageCheck.enabled) return "off";
|
|
2042
2087
|
return s.packageCheck.onMalicious === "review" ? "review" : "block";
|
|
2088
|
+
},
|
|
2089
|
+
"behavior.untrusted-content": (s) => {
|
|
2090
|
+
if (s.untrustedContent?.enabled === void 0) return void 0;
|
|
2091
|
+
if (!s.untrustedContent.enabled) return "off";
|
|
2092
|
+
return s.untrustedContent.afterExposure === "log-only" ? "log" : "review";
|
|
2043
2093
|
}
|
|
2044
2094
|
};
|
|
2045
2095
|
function resolveCheck(settings, id) {
|
|
@@ -3259,11 +3309,11 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3259
3309
|
const firstFlag = args.findIndex((a) => a == null || a.startsWith("-"));
|
|
3260
3310
|
args = firstFlag >= 0 ? args.slice(firstFlag) : [];
|
|
3261
3311
|
}
|
|
3262
|
-
let
|
|
3312
|
+
let positionals2 = 0;
|
|
3263
3313
|
let selectedProgram = false;
|
|
3264
3314
|
for (const a of args) {
|
|
3265
3315
|
if (a == null) {
|
|
3266
|
-
|
|
3316
|
+
positionals2++;
|
|
3267
3317
|
selectedProgram = true;
|
|
3268
3318
|
continue;
|
|
3269
3319
|
}
|
|
@@ -3274,13 +3324,13 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3274
3324
|
}
|
|
3275
3325
|
if (a === "-" && !selectedProgram) return true;
|
|
3276
3326
|
if (!a.startsWith("-")) {
|
|
3277
|
-
|
|
3327
|
+
positionals2++;
|
|
3278
3328
|
selectedProgram = true;
|
|
3279
3329
|
}
|
|
3280
3330
|
}
|
|
3281
3331
|
const redirs = stmt.Redirs || cmd.Redirs || [];
|
|
3282
3332
|
const stdinFed = redirs.some((r) => r && redirStdinOps().has(r.Op));
|
|
3283
|
-
if (
|
|
3333
|
+
if (positionals2 === 0 && (stdinFed || pipeFed)) {
|
|
3284
3334
|
if (!/^(bash|sh|zsh)$/i.test(interp)) return true;
|
|
3285
3335
|
}
|
|
3286
3336
|
return false;
|
|
@@ -3660,6 +3710,24 @@ function resolveWordLiteral(w) {
|
|
|
3660
3710
|
}
|
|
3661
3711
|
return s;
|
|
3662
3712
|
}
|
|
3713
|
+
function resolveWordPrefix(w) {
|
|
3714
|
+
const walk2 = (parts) => {
|
|
3715
|
+
let s = "";
|
|
3716
|
+
for (const p of parts) {
|
|
3717
|
+
if (p && typeof p === "object" && Array.isArray(p.Parts) && p.Dollar !== void 0) {
|
|
3718
|
+
const inner = walk2(p.Parts);
|
|
3719
|
+
s += inner.prefix;
|
|
3720
|
+
if (inner.dynamic) return { prefix: s, dynamic: true };
|
|
3721
|
+
continue;
|
|
3722
|
+
}
|
|
3723
|
+
const piece = resolvePart(p, false);
|
|
3724
|
+
if (piece === void 0 || piece === null) return { prefix: s, dynamic: true };
|
|
3725
|
+
s += piece;
|
|
3726
|
+
}
|
|
3727
|
+
return { prefix: s, dynamic: false };
|
|
3728
|
+
};
|
|
3729
|
+
return walk2(w?.Parts || []);
|
|
3730
|
+
}
|
|
3663
3731
|
function resolvePart(p, inQuotes) {
|
|
3664
3732
|
const t = syntax.NodeType(p);
|
|
3665
3733
|
if (t === "Lit") {
|
|
@@ -3707,7 +3775,7 @@ function parseDestHost(token) {
|
|
|
3707
3775
|
}
|
|
3708
3776
|
function destTokensForBinary(binary, args) {
|
|
3709
3777
|
const valueFlags = VALUE_FLAGS[binary] ?? /* @__PURE__ */ new Set();
|
|
3710
|
-
const
|
|
3778
|
+
const positionals2 = [];
|
|
3711
3779
|
const urlFlagValues = [];
|
|
3712
3780
|
for (let i = 0; i < args.length; i++) {
|
|
3713
3781
|
const tok = args[i];
|
|
@@ -3727,21 +3795,21 @@ function destTokensForBinary(binary, args) {
|
|
|
3727
3795
|
if (valueFlags.has(tok)) i++;
|
|
3728
3796
|
continue;
|
|
3729
3797
|
}
|
|
3730
|
-
|
|
3798
|
+
positionals2.push(tok);
|
|
3731
3799
|
}
|
|
3732
3800
|
switch (binary) {
|
|
3733
3801
|
case "curl":
|
|
3734
3802
|
case "wget":
|
|
3735
|
-
return [...urlFlagValues, ...
|
|
3803
|
+
return [...urlFlagValues, ...positionals2];
|
|
3736
3804
|
case "ssh":
|
|
3737
|
-
return
|
|
3805
|
+
return positionals2.slice(0, 1);
|
|
3738
3806
|
case "scp":
|
|
3739
3807
|
case "rsync":
|
|
3740
|
-
return
|
|
3808
|
+
return positionals2.filter((p) => p.includes(":") || p.includes("@"));
|
|
3741
3809
|
case "nc":
|
|
3742
3810
|
case "ncat":
|
|
3743
3811
|
case "netcat":
|
|
3744
|
-
return
|
|
3812
|
+
return positionals2.slice(0, 1);
|
|
3745
3813
|
default:
|
|
3746
3814
|
return [];
|
|
3747
3815
|
}
|
|
@@ -3758,16 +3826,18 @@ function extractShellDestinations(command) {
|
|
|
3758
3826
|
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
3759
3827
|
const callArgs = n.Args || [];
|
|
3760
3828
|
if (callArgs.length === 0) return true;
|
|
3761
|
-
const
|
|
3829
|
+
const words = callArgs.map((a) => resolveWordLiteral(a));
|
|
3830
|
+
const at = unwrapCommandHead(words);
|
|
3831
|
+
const name = (words[at] || "").toLowerCase().split("/").pop() ?? "";
|
|
3762
3832
|
if (!NET_BINARIES.has(name)) return true;
|
|
3763
|
-
const rest =
|
|
3833
|
+
const rest = words.slice(at + 1);
|
|
3764
3834
|
for (const raw of destTokensForBinary(name, rest)) {
|
|
3765
|
-
const
|
|
3766
|
-
if (!
|
|
3767
|
-
const key = `${name}:${
|
|
3835
|
+
const host2 = parseDestHost(raw);
|
|
3836
|
+
if (!host2) continue;
|
|
3837
|
+
const key = `${name}:${host2}`;
|
|
3768
3838
|
if (seen.has(key)) continue;
|
|
3769
3839
|
seen.add(key);
|
|
3770
|
-
out.push({ host, binary: name, raw });
|
|
3840
|
+
out.push({ host: host2, binary: name, raw });
|
|
3771
3841
|
}
|
|
3772
3842
|
return true;
|
|
3773
3843
|
});
|
|
@@ -4659,36 +4729,129 @@ var BASH_TOOL_NAMES = /* @__PURE__ */ new Set([
|
|
|
4659
4729
|
"shell",
|
|
4660
4730
|
"exec_command"
|
|
4661
4731
|
]);
|
|
4662
|
-
var MCP_EXECUTORS = /* @__PURE__ */ new Set([
|
|
4732
|
+
var MCP_EXECUTORS = /* @__PURE__ */ new Set([
|
|
4733
|
+
...BASH_TOOL_NAMES,
|
|
4734
|
+
"exec",
|
|
4735
|
+
"run_command",
|
|
4736
|
+
"terminal",
|
|
4737
|
+
"execute_command",
|
|
4738
|
+
"execute_shell",
|
|
4739
|
+
"execute_shell_command",
|
|
4740
|
+
"shell_execute",
|
|
4741
|
+
"run_shell",
|
|
4742
|
+
"run_terminal_command",
|
|
4743
|
+
"start_process"
|
|
4744
|
+
]);
|
|
4745
|
+
var BUILTIN_FIELDS = ["command", "cmd", "script"];
|
|
4746
|
+
var ARGV_FIELDS = ["args", "argv"];
|
|
4747
|
+
var BARE_WORD = /^[A-Za-z0-9_./+:@%,-]+$/;
|
|
4748
|
+
var MAX_ARGV_CHARACTERS = 262144;
|
|
4663
4749
|
function isBashTool(tool) {
|
|
4664
4750
|
return BASH_TOOL_NAMES.has(tool.toLowerCase());
|
|
4665
4751
|
}
|
|
4666
|
-
function
|
|
4752
|
+
function inspectionLayers(policy) {
|
|
4753
|
+
return { trusted: policy.toolInspection, project: policy.projectToolInspection };
|
|
4754
|
+
}
|
|
4755
|
+
function isShellEntry(value) {
|
|
4756
|
+
return typeof value === "object" && value !== null && value.kind === "shell" && typeof value.field === "string" && Object.keys(value).length === 2;
|
|
4757
|
+
}
|
|
4758
|
+
function isInspectionLayers(input) {
|
|
4759
|
+
const trusted = input.trusted;
|
|
4760
|
+
return typeof trusted === "object" && trusted !== null && !isShellEntry(trusted);
|
|
4761
|
+
}
|
|
4762
|
+
function layersOf(input) {
|
|
4763
|
+
return isInspectionLayers(input) ? { trusted: input.trusted, project: input.project ?? {} } : { trusted: input, project: {} };
|
|
4764
|
+
}
|
|
4765
|
+
function entryOf(tool, inspection) {
|
|
4667
4766
|
const pattern = Object.keys(inspection).find((p) => matchesPattern(tool, p));
|
|
4668
4767
|
return pattern === void 0 ? void 0 : inspection[pattern];
|
|
4669
4768
|
}
|
|
4769
|
+
function inspectionEntry(tool, inspection = {}) {
|
|
4770
|
+
const { trusted, project } = layersOf(inspection);
|
|
4771
|
+
return entryOf(tool, trusted) ?? entryOf(tool, project);
|
|
4772
|
+
}
|
|
4773
|
+
function executorName(tool) {
|
|
4774
|
+
const name = tool.toLowerCase();
|
|
4775
|
+
if (!name.startsWith("mcp__")) return name;
|
|
4776
|
+
const at = name.lastIndexOf("__");
|
|
4777
|
+
return at >= "mcp__".length ? name.slice(at + 2) : name;
|
|
4778
|
+
}
|
|
4779
|
+
function entryFields(entry) {
|
|
4780
|
+
if (typeof entry === "object") return [entry.field];
|
|
4781
|
+
return entry === "command" ? ["command"] : null;
|
|
4782
|
+
}
|
|
4670
4783
|
function shellFields(tool, inspection) {
|
|
4671
4784
|
if (isBashTool(tool)) return ["command"];
|
|
4672
|
-
const
|
|
4673
|
-
|
|
4674
|
-
if (
|
|
4675
|
-
const
|
|
4676
|
-
|
|
4785
|
+
const { trusted, project } = layersOf(inspection);
|
|
4786
|
+
const trustedEntry = entryOf(tool, trusted);
|
|
4787
|
+
if (trustedEntry !== void 0) return entryFields(trustedEntry);
|
|
4788
|
+
const builtin = MCP_EXECUTORS.has(executorName(tool)) ? BUILTIN_FIELDS : null;
|
|
4789
|
+
const projectEntry = entryOf(tool, project);
|
|
4790
|
+
if (projectEntry === void 0) return builtin;
|
|
4791
|
+
const added = entryFields(projectEntry);
|
|
4792
|
+
if (!builtin) return added;
|
|
4793
|
+
if (!added) return builtin;
|
|
4794
|
+
return [.../* @__PURE__ */ new Set([...builtin, ...added])];
|
|
4677
4795
|
}
|
|
4678
4796
|
function isShellShapedTool(tool, inspection = {}) {
|
|
4679
4797
|
return shellFields(tool, inspection) !== null;
|
|
4680
4798
|
}
|
|
4799
|
+
function shellWord(word) {
|
|
4800
|
+
if (BARE_WORD.test(word)) return word;
|
|
4801
|
+
return word === "" ? "''" : `'${word.replace(/'/g, `'\\''`)}'`;
|
|
4802
|
+
}
|
|
4803
|
+
function isStringArray(value) {
|
|
4804
|
+
return Array.isArray(value) && value.every((item) => typeof item === "string");
|
|
4805
|
+
}
|
|
4806
|
+
function commandLine(args, fieldPath, value, native) {
|
|
4807
|
+
const missing = { reason: "Shell command field is missing or is not a string" };
|
|
4808
|
+
const unreadable = { reason: "Shell command arguments could not be read" };
|
|
4809
|
+
if (typeof value !== "string" && (native || !Array.isArray(value))) return missing;
|
|
4810
|
+
const dot = fieldPath.lastIndexOf(".");
|
|
4811
|
+
const parent = dot === -1 ? args : getNestedValue(args, fieldPath.slice(0, dot));
|
|
4812
|
+
const siblings = ARGV_FIELDS.map((key) => ({
|
|
4813
|
+
key,
|
|
4814
|
+
value: parent && typeof parent === "object" ? parent[key] : void 0
|
|
4815
|
+
})).filter(({ value: value2 }) => value2 !== void 0 && value2 !== null);
|
|
4816
|
+
let argv = siblings[0];
|
|
4817
|
+
if (native) argv = siblings.find(({ value: v }) => isStringArray(v));
|
|
4818
|
+
else if (siblings.length === 2 && JSON.stringify(siblings[0].value) !== JSON.stringify(siblings[1].value))
|
|
4819
|
+
return { reason: "Shell command arguments disagree" };
|
|
4820
|
+
let command;
|
|
4821
|
+
let source = fieldPath;
|
|
4822
|
+
if (Array.isArray(value)) {
|
|
4823
|
+
if (argv || !value.length || !isStringArray(value)) return unreadable;
|
|
4824
|
+
command = value.map(shellWord).join(" ");
|
|
4825
|
+
} else if (!argv) {
|
|
4826
|
+
return { command: value, fieldPath };
|
|
4827
|
+
} else {
|
|
4828
|
+
if (!isStringArray(argv.value)) return unreadable;
|
|
4829
|
+
if (!argv.value.length) return { command: value, fieldPath };
|
|
4830
|
+
command = `${value} ${argv.value.map(shellWord).join(" ")}`;
|
|
4831
|
+
source = `${fieldPath}+${argv.key}`;
|
|
4832
|
+
}
|
|
4833
|
+
if (command.length > MAX_ARGV_CHARACTERS)
|
|
4834
|
+
return { reason: "Shell command arguments exceed the inspectable size" };
|
|
4835
|
+
return { command, fieldPath: source };
|
|
4836
|
+
}
|
|
4681
4837
|
function resolveShellInput(tool, args, inspection = {}) {
|
|
4682
4838
|
const fields = shellFields(tool, inspection);
|
|
4683
4839
|
if (!fields) return { kind: "not-shell" };
|
|
4684
4840
|
const values = fields.map((fieldPath) => ({ fieldPath, value: getNestedValue(args, fieldPath) })).filter(({ value }) => value !== void 0 && value !== null && value !== "");
|
|
4685
|
-
if (!values.length
|
|
4841
|
+
if (!values.length) {
|
|
4686
4842
|
return { kind: "uninspectable", reason: "Shell command field is missing or is not a string" };
|
|
4687
4843
|
}
|
|
4688
|
-
|
|
4844
|
+
const native = isBashTool(tool);
|
|
4845
|
+
const lines = values.map(({ fieldPath, value }) => commandLine(args, fieldPath, value, native));
|
|
4846
|
+
const failed = lines.find((line) => "reason" in line);
|
|
4847
|
+
if (failed) return { kind: "uninspectable", reason: failed.reason };
|
|
4848
|
+
const commands = lines.filter(
|
|
4849
|
+
(line) => "command" in line
|
|
4850
|
+
);
|
|
4851
|
+
if (new Set(commands.map(({ command }) => command)).size !== 1) {
|
|
4689
4852
|
return { kind: "uninspectable", reason: "Multiple shell command fields disagree" };
|
|
4690
4853
|
}
|
|
4691
|
-
return { kind: "shell",
|
|
4854
|
+
return { kind: "shell", ...commands[0] };
|
|
4692
4855
|
}
|
|
4693
4856
|
function shellRuleArgs(tool, args, ruleTool, inspection = {}) {
|
|
4694
4857
|
if (!ruleTool || !matchesPattern("bash", ruleTool) || matchesPattern(tool, ruleTool)) return args;
|
|
@@ -5301,6 +5464,33 @@ var SYSTEM_AUTH_FILES = [
|
|
|
5301
5464
|
var SYSTEM_AUTH_DIRS = ["/etc/security", "/etc/pam.d", "/etc/sudoers.d"];
|
|
5302
5465
|
var PASSWORD_HASH_FILES = ["/etc/shadow", "/etc/gshadow"];
|
|
5303
5466
|
var STARTUP_NAMES = [".bashrc", ".zshrc", ".profile", ".bash_profile"];
|
|
5467
|
+
var AGENT_INSTRUCTION_FILES = [
|
|
5468
|
+
".gitlab-ci.yml",
|
|
5469
|
+
"CLAUDE.md",
|
|
5470
|
+
"AGENTS.md",
|
|
5471
|
+
".cursorrules",
|
|
5472
|
+
".mcp.json",
|
|
5473
|
+
".vscode/settings.json",
|
|
5474
|
+
"package.json"
|
|
5475
|
+
];
|
|
5476
|
+
var AGENT_INSTRUCTION_DIRS = [
|
|
5477
|
+
".github/workflows",
|
|
5478
|
+
".claude",
|
|
5479
|
+
".cursor",
|
|
5480
|
+
".git/hooks",
|
|
5481
|
+
".husky"
|
|
5482
|
+
];
|
|
5483
|
+
function isAgentInstructionPath(absPath, root) {
|
|
5484
|
+
const r = root.replace(/\/$/, "");
|
|
5485
|
+
if (!(absPath === r || absPath.startsWith(r + "/"))) return false;
|
|
5486
|
+
const rel = absPath.slice(r.length + 1);
|
|
5487
|
+
if (AGENT_INSTRUCTION_FILES.includes(rel)) return true;
|
|
5488
|
+
return AGENT_INSTRUCTION_DIRS.some((d) => rel === d || rel.startsWith(d + "/"));
|
|
5489
|
+
}
|
|
5490
|
+
function isInside(root, p) {
|
|
5491
|
+
const r = root.replace(/\/$/, "") || "/";
|
|
5492
|
+
return p === r || p.startsWith(r === "/" ? "/" : r + "/");
|
|
5493
|
+
}
|
|
5304
5494
|
var LEGACY_SYSTEM_PATH_RE = /^(?:[a-zA-Z]:)?\/etc\/(?:passwd|shadow|sudoers)$/;
|
|
5305
5495
|
function isPasswordHashPath(p) {
|
|
5306
5496
|
return PASSWORD_HASH_FILES.includes(p);
|
|
@@ -7546,20 +7736,26 @@ var BIP39_PUBLIC_VECTORS = /* @__PURE__ */ new Set([
|
|
|
7546
7736
|
var indices = new Map(BIP39_ENGLISH.map((word, i) => [word, i]));
|
|
7547
7737
|
var lengths = [24, 21, 18, 15, 12];
|
|
7548
7738
|
var hash = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest();
|
|
7549
|
-
|
|
7550
|
-
|
|
7739
|
+
var MAX_MNEMONIC_HASHES = 25e3;
|
|
7740
|
+
function findMnemonic(text, budget = { hashes: 0, reasons: /* @__PURE__ */ new Set() }) {
|
|
7551
7741
|
let run = [];
|
|
7742
|
+
let runIndex = [];
|
|
7552
7743
|
let previousEnd = 0;
|
|
7553
7744
|
const rejected = /* @__PURE__ */ new Set();
|
|
7554
7745
|
const inspect = () => {
|
|
7746
|
+
if (run.length < 12) return false;
|
|
7747
|
+
const ascending = new Array(run.length).fill(0);
|
|
7748
|
+
for (let i = 1; i < run.length; i++)
|
|
7749
|
+
ascending[i] = ascending[i - 1] + (runIndex[i] > runIndex[i - 1] ? 1 : 0);
|
|
7555
7750
|
for (let start = 0; start + 12 <= run.length; start++) {
|
|
7556
7751
|
for (const count of lengths) {
|
|
7557
7752
|
if (start + count > run.length) continue;
|
|
7753
|
+
if (ascending[start + count - 1] - ascending[start] === count - 1) continue;
|
|
7558
7754
|
const candidate = run.slice(start, start + count);
|
|
7559
7755
|
const sentence = candidate.join(" ");
|
|
7560
7756
|
if (rejected.has(sentence)) continue;
|
|
7561
|
-
if (++budget.
|
|
7562
|
-
budget.reasons.add("mnemonic-
|
|
7757
|
+
if (++budget.hashes > MAX_MNEMONIC_HASHES) {
|
|
7758
|
+
budget.reasons.add("mnemonic-budget");
|
|
7563
7759
|
return false;
|
|
7564
7760
|
}
|
|
7565
7761
|
if (BIP39_PUBLIC_VECTORS.has(hash(sentence).toString("hex"))) {
|
|
@@ -7577,13 +7773,18 @@ function findMnemonic(text, budget = { candidates: 0, reasons: /* @__PURE__ */ n
|
|
|
7577
7773
|
}
|
|
7578
7774
|
return false;
|
|
7579
7775
|
};
|
|
7580
|
-
for (const word of
|
|
7581
|
-
|
|
7776
|
+
for (const word of text.matchAll(/[a-zA-Z]+/g)) {
|
|
7777
|
+
const index = indices.get(word[0]);
|
|
7778
|
+
if (index === void 0 || run.length && !/^\s+$/.test(text.slice(previousEnd, word.index))) {
|
|
7582
7779
|
if (inspect()) return true;
|
|
7583
|
-
if (budget.reasons.has("mnemonic-
|
|
7780
|
+
if (budget.reasons.has("mnemonic-budget")) return false;
|
|
7584
7781
|
run = [];
|
|
7782
|
+
runIndex = [];
|
|
7783
|
+
}
|
|
7784
|
+
if (index !== void 0) {
|
|
7785
|
+
run.push(word[0]);
|
|
7786
|
+
runIndex.push(index);
|
|
7585
7787
|
}
|
|
7586
|
-
if (indices.has(word[0])) run.push(word[0]);
|
|
7587
7788
|
previousEnd = word.index + word[0].length;
|
|
7588
7789
|
}
|
|
7589
7790
|
return inspect();
|
|
@@ -7826,6 +8027,10 @@ function validateCask(raw) {
|
|
|
7826
8027
|
|
|
7827
8028
|
// src/dlp/normalize.ts
|
|
7828
8029
|
var INVISIBLE_RE = /[͏----︀-️]|[\u{E0000}-\u{E007F}]/gu;
|
|
8030
|
+
function isInvisibleChar(char) {
|
|
8031
|
+
return INVISIBLE_ONE.test(char);
|
|
8032
|
+
}
|
|
8033
|
+
var INVISIBLE_ONE = new RegExp(`^(?:${INVISIBLE_RE.source.split("|")[0]})$`, "u");
|
|
7829
8034
|
function stripInvisible(text) {
|
|
7830
8035
|
return text.replace(INVISIBLE_RE, "");
|
|
7831
8036
|
}
|
|
@@ -8001,7 +8206,7 @@ function scanInjection(text, ctx = {}) {
|
|
|
8001
8206
|
}
|
|
8002
8207
|
}
|
|
8003
8208
|
if (matched.length === 0) return null;
|
|
8004
|
-
const untrusted = !!ctx.tool && UNTRUSTED_TOOLS.test(ctx.tool);
|
|
8209
|
+
const untrusted = ctx.untrusted ?? (!!ctx.tool && UNTRUSTED_TOOLS.test(ctx.tool));
|
|
8005
8210
|
const score = matched.length + (untrusted ? 1 : 0);
|
|
8006
8211
|
const confidence = score >= 3 ? "high" : score === 2 ? "medium" : "low";
|
|
8007
8212
|
return { signals: untrusted ? [...matched, "untrusted-origin"] : matched, confidence };
|
|
@@ -8789,6 +8994,46 @@ function matchArgumentText(text, fieldPath, budget) {
|
|
|
8789
8994
|
}
|
|
8790
8995
|
return best;
|
|
8791
8996
|
}
|
|
8997
|
+
var BATCH_SEPARATOR = "\n";
|
|
8998
|
+
function matchArgumentBatch(fragments, fieldPath, budget) {
|
|
8999
|
+
if (!fragments.length) return null;
|
|
9000
|
+
const text = fragments.join(BATCH_SEPARATOR);
|
|
9001
|
+
const lower2 = text.toLowerCase();
|
|
9002
|
+
let best = null;
|
|
9003
|
+
for (const pattern of DLP_PATTERNS) {
|
|
9004
|
+
if (pattern.keywords && !pattern.keywords.some((kw) => lower2.includes(kw.toLowerCase())))
|
|
9005
|
+
continue;
|
|
9006
|
+
const flags = pattern.regex.flags.replace(/[gmy]/g, "");
|
|
9007
|
+
if (!new RegExp(pattern.regex.source, flags + "m").test(text)) continue;
|
|
9008
|
+
for (const fragment of fragments) {
|
|
9009
|
+
if (firstAcceptedMatch(pattern, fragment) === null) continue;
|
|
9010
|
+
const severity = pattern.contextBoost && isAssignmentContext(fragment) ? "block" : pattern.severity;
|
|
9011
|
+
if (severity === "block")
|
|
9012
|
+
return {
|
|
9013
|
+
patternName: pattern.name,
|
|
9014
|
+
fieldPath,
|
|
9015
|
+
redactedSample: "[encoded secret]",
|
|
9016
|
+
severity
|
|
9017
|
+
};
|
|
9018
|
+
best ??= {
|
|
9019
|
+
patternName: pattern.name,
|
|
9020
|
+
fieldPath,
|
|
9021
|
+
redactedSample: "[encoded secret]",
|
|
9022
|
+
severity
|
|
9023
|
+
};
|
|
9024
|
+
if (!pattern.contextBoost) break;
|
|
9025
|
+
}
|
|
9026
|
+
}
|
|
9027
|
+
if (findMnemonic(text, budget)) {
|
|
9028
|
+
return {
|
|
9029
|
+
patternName: "BIP-39 Recovery Phrase",
|
|
9030
|
+
fieldPath,
|
|
9031
|
+
redactedSample: "[recovery phrase]",
|
|
9032
|
+
severity: "block"
|
|
9033
|
+
};
|
|
9034
|
+
}
|
|
9035
|
+
return best;
|
|
9036
|
+
}
|
|
8792
9037
|
function scanArgs(args, depth = 0, fieldPath = "args") {
|
|
8793
9038
|
if (depth > MAX_DEPTH2 || args === null || args === void 0) return null;
|
|
8794
9039
|
if (Array.isArray(args)) {
|
|
@@ -9515,7 +9760,25 @@ var TUNING_FIELDS = [
|
|
|
9515
9760
|
name: "onlineFallback",
|
|
9516
9761
|
legacy: ["packageCheck", "onlineFallback"]
|
|
9517
9762
|
},
|
|
9518
|
-
{ checkId: "loading.malicious-package", name: "allow", legacy: ["packageCheck", "allow"] }
|
|
9763
|
+
{ checkId: "loading.malicious-package", name: "allow", legacy: ["packageCheck", "allow"] },
|
|
9764
|
+
// fw#318: the verdict carries off / log (log-only) / review; the tuning
|
|
9765
|
+
// carries whether a review asks once per destination or every time, the
|
|
9766
|
+
// frame around outside content, and the organisation's own domains.
|
|
9767
|
+
{
|
|
9768
|
+
checkId: "behavior.untrusted-content",
|
|
9769
|
+
name: "afterExposure",
|
|
9770
|
+
legacy: ["untrustedContent", "afterExposure"]
|
|
9771
|
+
},
|
|
9772
|
+
{
|
|
9773
|
+
checkId: "behavior.untrusted-content",
|
|
9774
|
+
name: "spotlight",
|
|
9775
|
+
legacy: ["untrustedContent", "spotlight"]
|
|
9776
|
+
},
|
|
9777
|
+
{
|
|
9778
|
+
checkId: "behavior.untrusted-content",
|
|
9779
|
+
name: "orgDomains",
|
|
9780
|
+
legacy: ["untrustedContent", "orgDomains"]
|
|
9781
|
+
}
|
|
9519
9782
|
];
|
|
9520
9783
|
function tuningFromLegacyPolicy(policy) {
|
|
9521
9784
|
const out = {};
|
|
@@ -9594,6 +9857,10 @@ function checksFromLegacyPolicy(policy, mode) {
|
|
|
9594
9857
|
if (pkg?.enabled === false) out["loading.malicious-package"] = "off";
|
|
9595
9858
|
else if (pkg?.enabled === true)
|
|
9596
9859
|
out["loading.malicious-package"] = pkg.onMalicious === "review" ? "review" : "block";
|
|
9860
|
+
const uc = policy.untrustedContent;
|
|
9861
|
+
if (uc?.enabled === false) out["behavior.untrusted-content"] = "off";
|
|
9862
|
+
else if (uc?.enabled === true)
|
|
9863
|
+
out["behavior.untrusted-content"] = uc.afterExposure === "log-only" ? "log" : "review";
|
|
9597
9864
|
if (mode === "strict") out["commands.unknown"] = "review";
|
|
9598
9865
|
return out;
|
|
9599
9866
|
}
|
|
@@ -9675,6 +9942,13 @@ function checkToLegacyPolicy(policy, id, v) {
|
|
|
9675
9942
|
return offOr("packageCheck", () => {
|
|
9676
9943
|
obj("packageCheck").onMalicious = v === "review" ? "review" : "block";
|
|
9677
9944
|
});
|
|
9945
|
+
case "behavior.untrusted-content":
|
|
9946
|
+
if (v !== "off" && v !== "log" && v !== "review") return false;
|
|
9947
|
+
return offOr("untrustedContent", () => {
|
|
9948
|
+
const uc = obj("untrustedContent");
|
|
9949
|
+
if (v === "log") uc.afterExposure = "log-only";
|
|
9950
|
+
else if (uc.afterExposure !== "ask-every-time") uc.afterExposure = "ask-once";
|
|
9951
|
+
});
|
|
9678
9952
|
default:
|
|
9679
9953
|
return false;
|
|
9680
9954
|
}
|
|
@@ -9694,6 +9968,7 @@ var MAP_GOVERNED = /* @__PURE__ */ new Set([
|
|
|
9694
9968
|
"commands.temp-binary",
|
|
9695
9969
|
"commands.disk-destroy",
|
|
9696
9970
|
"commands.dangerous-word",
|
|
9971
|
+
"commands.node9-disarm",
|
|
9697
9972
|
"data.pipe-chain"
|
|
9698
9973
|
]);
|
|
9699
9974
|
var KNOB_GOVERNED = {
|
|
@@ -9705,7 +9980,8 @@ var KNOB_GOVERNED = {
|
|
|
9705
9980
|
"behavior.loops": ["off", "block"],
|
|
9706
9981
|
"behavior.prompt-injection": ["off", "log"],
|
|
9707
9982
|
"loading.skill-tamper": ["off", "log", "block"],
|
|
9708
|
-
"loading.malicious-package": ["off", "review", "block"]
|
|
9983
|
+
"loading.malicious-package": ["off", "review", "block"],
|
|
9984
|
+
"behavior.untrusted-content": ["off", "log", "review"]
|
|
9709
9985
|
};
|
|
9710
9986
|
function isKnobGoverned(id) {
|
|
9711
9987
|
return id in KNOB_GOVERNED;
|
|
@@ -9744,39 +10020,39 @@ var DEFAULT_EGRESS_ALLOWLIST = [
|
|
|
9744
10020
|
"deb.debian.org",
|
|
9745
10021
|
"*.ubuntu.com"
|
|
9746
10022
|
];
|
|
9747
|
-
function hostMatches(
|
|
10023
|
+
function hostMatches(host2, pattern) {
|
|
9748
10024
|
const p = pattern.trim().toLowerCase();
|
|
9749
10025
|
if (!p) return false;
|
|
9750
10026
|
if (p === "*") return true;
|
|
9751
|
-
const h = canonicalHost(
|
|
10027
|
+
const h = canonicalHost(host2);
|
|
9752
10028
|
if (p.startsWith("*.")) {
|
|
9753
10029
|
const suffix = canonicalHost(p.slice(2));
|
|
9754
10030
|
return h === suffix || h.endsWith("." + suffix);
|
|
9755
10031
|
}
|
|
9756
10032
|
return h === canonicalHost(p);
|
|
9757
10033
|
}
|
|
9758
|
-
function matchesAny(
|
|
9759
|
-
for (const p of patterns ?? []) if (hostMatches(
|
|
10034
|
+
function matchesAny(host2, patterns) {
|
|
10035
|
+
for (const p of patterns ?? []) if (hostMatches(host2, p)) return true;
|
|
9760
10036
|
return false;
|
|
9761
10037
|
}
|
|
9762
10038
|
var PRIVATE_HOST_SUFFIXES = [".local", ".internal", ".localhost"];
|
|
9763
|
-
function isUniqueLocalV6(
|
|
9764
|
-
const ip = normalizeIpLiteral(
|
|
10039
|
+
function isUniqueLocalV6(host2) {
|
|
10040
|
+
const ip = normalizeIpLiteral(host2);
|
|
9765
10041
|
if (!ip || !ip.includes(":")) return false;
|
|
9766
10042
|
const g = expandIpv6(ip);
|
|
9767
10043
|
return g !== null && (g[0] & 65024) === 64512;
|
|
9768
10044
|
}
|
|
9769
|
-
function isPrivateHost(
|
|
9770
|
-
const h =
|
|
10045
|
+
function isPrivateHost(host2) {
|
|
10046
|
+
const h = host2.trim().toLowerCase().replace(/\.$/, "");
|
|
9771
10047
|
const m = classifySsrf(h);
|
|
9772
10048
|
if (m) return m.kind === "address" && (m.tier === "private" || m.tier === "unspecified");
|
|
9773
10049
|
if (h === "localhost") return true;
|
|
9774
10050
|
if (PRIVATE_HOST_SUFFIXES.some((s) => h.endsWith(s))) return true;
|
|
9775
10051
|
return isUniqueLocalV6(h);
|
|
9776
10052
|
}
|
|
9777
|
-
function canonicalHost(
|
|
9778
|
-
const ip = normalizeIpLiteral(
|
|
9779
|
-
return ip ??
|
|
10053
|
+
function canonicalHost(host2) {
|
|
10054
|
+
const ip = normalizeIpLiteral(host2);
|
|
10055
|
+
return ip ?? host2.trim().toLowerCase().replace(/\.$/, "");
|
|
9780
10056
|
}
|
|
9781
10057
|
function evaluateEgress(dests, policy) {
|
|
9782
10058
|
if (!policy.enabled) return null;
|
|
@@ -10184,8 +10460,8 @@ function extractToolDestinations(toolName, args) {
|
|
|
10184
10460
|
const out = [];
|
|
10185
10461
|
for (const path of paths) {
|
|
10186
10462
|
for (const value of valuesAt(args, path)) {
|
|
10187
|
-
const
|
|
10188
|
-
if (
|
|
10463
|
+
const host2 = hostOf(value);
|
|
10464
|
+
if (host2) out.push({ host: host2, binary: toolName, raw: value });
|
|
10189
10465
|
}
|
|
10190
10466
|
}
|
|
10191
10467
|
return out;
|
|
@@ -10199,13 +10475,13 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
10199
10475
|
if (!paths) return null;
|
|
10200
10476
|
for (const path of paths) {
|
|
10201
10477
|
for (const value of valuesAt(args, path)) {
|
|
10202
|
-
const
|
|
10203
|
-
if (!
|
|
10204
|
-
const m = classifySsrf(
|
|
10478
|
+
const host2 = hostOf(value);
|
|
10479
|
+
if (!host2) continue;
|
|
10480
|
+
const m = classifySsrf(host2);
|
|
10205
10481
|
if (!m) continue;
|
|
10206
10482
|
if (isStrictGatedTier(m.tier) && !opts.ssrfStrict) continue;
|
|
10207
10483
|
if (m.overridable && ssrfExemptMatches(opts.ssrfAllow, m.normalized)) continue;
|
|
10208
|
-
return { ...m, argPath: path, host, reason: ssrfReason(m,
|
|
10484
|
+
return { ...m, argPath: path, host: host2, reason: ssrfReason(m, host2) };
|
|
10209
10485
|
}
|
|
10210
10486
|
}
|
|
10211
10487
|
return null;
|
|
@@ -10216,12 +10492,23 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
10216
10492
|
|
|
10217
10493
|
// src/dlp/secret-views.ts
|
|
10218
10494
|
var SECRET_VIEW_LIMITS = {
|
|
10495
|
+
/** A decoded text that itself decodes is followed this many layers; a deeper layer is reviewed. */
|
|
10219
10496
|
maxDepth: 4,
|
|
10220
|
-
|
|
10221
|
-
|
|
10222
|
-
|
|
10223
|
-
|
|
10497
|
+
/** Nested views per parent view, and nested text per call; past either the call is reviewed. */
|
|
10498
|
+
maxNestedViewsPerLeaf: 64,
|
|
10499
|
+
maxNestedBytes: 1048576,
|
|
10500
|
+
/** Joined hostname-label text per call; past it the call is reviewed. */
|
|
10501
|
+
maxJoinedLabelBytes: 1048576,
|
|
10502
|
+
/** Decoded fragments are matched in batches of about this many characters. */
|
|
10503
|
+
batchCharacters: 65536,
|
|
10504
|
+
/** Only a valid DNS name has its labels joined. */
|
|
10505
|
+
maxHostLength: 253,
|
|
10506
|
+
maxLabelLength: 63,
|
|
10507
|
+
maxLabels: 127
|
|
10224
10508
|
};
|
|
10509
|
+
function newSecretViewBudget() {
|
|
10510
|
+
return { hashes: 0, nestedBytes: 0, joinedLabelBytes: 0, reasons: /* @__PURE__ */ new Set() };
|
|
10511
|
+
}
|
|
10225
10512
|
function textBytes(buf) {
|
|
10226
10513
|
if (buf.length < 16) return null;
|
|
10227
10514
|
const text = buf.toString("utf8");
|
|
@@ -10240,13 +10527,41 @@ function percentOnce(text) {
|
|
|
10240
10527
|
}
|
|
10241
10528
|
});
|
|
10242
10529
|
}
|
|
10530
|
+
function* wrappedBase64(text) {
|
|
10531
|
+
if (!text.includes("\n")) return;
|
|
10532
|
+
const word = /^[A-Za-z0-9+/_-]+={0,2}$/;
|
|
10533
|
+
let run = [];
|
|
10534
|
+
let width = 0;
|
|
10535
|
+
const flush = function* () {
|
|
10536
|
+
if (run.length >= 2) yield run.join("");
|
|
10537
|
+
run = [];
|
|
10538
|
+
width = 0;
|
|
10539
|
+
};
|
|
10540
|
+
for (const raw of text.split("\n")) {
|
|
10541
|
+
const line = raw.trim();
|
|
10542
|
+
const full = line.length >= 16 && word.test(line) && !line.includes("=");
|
|
10543
|
+
if (full && (!run.length || line.length === width)) {
|
|
10544
|
+
run.push(line);
|
|
10545
|
+
width = line.length;
|
|
10546
|
+
continue;
|
|
10547
|
+
}
|
|
10548
|
+
if (run.length && word.test(line) && line.length >= 2 && line.length <= width) {
|
|
10549
|
+
run.push(line);
|
|
10550
|
+
yield* flush();
|
|
10551
|
+
continue;
|
|
10552
|
+
}
|
|
10553
|
+
yield* flush();
|
|
10554
|
+
if (full) {
|
|
10555
|
+
run.push(line);
|
|
10556
|
+
width = line.length;
|
|
10557
|
+
}
|
|
10558
|
+
}
|
|
10559
|
+
yield* flush();
|
|
10560
|
+
}
|
|
10243
10561
|
function* encodedRegions(text, budget) {
|
|
10244
10562
|
yield [text, false];
|
|
10563
|
+
for (const block of wrappedBase64(text)) yield [block, false];
|
|
10245
10564
|
for (const match of text.matchAll(/(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,30}:\/\/[^\s<>"']+/gi)) {
|
|
10246
|
-
if (++budget.candidates > SECRET_VIEW_LIMITS.maxCandidates) {
|
|
10247
|
-
budget.reasons.add("decode-candidates");
|
|
10248
|
-
return;
|
|
10249
|
-
}
|
|
10250
10565
|
try {
|
|
10251
10566
|
new URL(match[0]);
|
|
10252
10567
|
} catch {
|
|
@@ -10256,16 +10571,18 @@ function* encodedRegions(text, budget) {
|
|
|
10256
10571
|
/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/i
|
|
10257
10572
|
);
|
|
10258
10573
|
if (!parts) continue;
|
|
10259
|
-
const
|
|
10574
|
+
const host2 = parts[1].slice(parts[1].lastIndexOf("@") + 1).replace(/:\d+$/, "");
|
|
10260
10575
|
const regions = [
|
|
10261
10576
|
parts[1],
|
|
10262
|
-
...
|
|
10577
|
+
...host2.split("."),
|
|
10263
10578
|
...parts[2].split("/"),
|
|
10264
10579
|
...(parts[3] ?? "").split("&"),
|
|
10265
10580
|
parts[4] ?? ""
|
|
10266
10581
|
];
|
|
10267
10582
|
for (const region of regions) if (region) yield [region, false];
|
|
10268
|
-
const labels =
|
|
10583
|
+
const labels = host2.split(".");
|
|
10584
|
+
if (host2.length > SECRET_VIEW_LIMITS.maxHostLength || labels.length > SECRET_VIEW_LIMITS.maxLabels || !labels.every((l) => l.length >= 1 && l.length <= SECRET_VIEW_LIMITS.maxLabelLength))
|
|
10585
|
+
continue;
|
|
10269
10586
|
for (let start = 0; start < labels.length; start++) {
|
|
10270
10587
|
let joined = labels[start];
|
|
10271
10588
|
for (let end = start + 1; end < Math.min(labels.length, start + 8); end++) {
|
|
@@ -10273,11 +10590,13 @@ function* encodedRegions(text, budget) {
|
|
|
10273
10590
|
if (!run.every((s) => /^[a-f0-9]{2,}$/i.test(s)) && !run.every((s) => /^[A-Z2-7]{4,}$/i.test(s)))
|
|
10274
10591
|
break;
|
|
10275
10592
|
joined += labels[end];
|
|
10276
|
-
if (
|
|
10277
|
-
|
|
10593
|
+
if (joined.length < 16) continue;
|
|
10594
|
+
budget.joinedLabelBytes += joined.length;
|
|
10595
|
+
if (budget.joinedLabelBytes > SECRET_VIEW_LIMITS.maxJoinedLabelBytes) {
|
|
10596
|
+
budget.reasons.add("decode-labels");
|
|
10278
10597
|
return;
|
|
10279
10598
|
}
|
|
10280
|
-
|
|
10599
|
+
yield [joined, true];
|
|
10281
10600
|
}
|
|
10282
10601
|
}
|
|
10283
10602
|
}
|
|
@@ -10314,10 +10633,6 @@ function* decodedCandidates(text, budget) {
|
|
|
10314
10633
|
if (joined) yield ["dns-labels", region];
|
|
10315
10634
|
for (const [kind, re] of families) {
|
|
10316
10635
|
for (const match of region.matchAll(re)) {
|
|
10317
|
-
if (++budget.candidates > SECRET_VIEW_LIMITS.maxCandidates) {
|
|
10318
|
-
budget.reasons.add("decode-candidates");
|
|
10319
|
-
return;
|
|
10320
|
-
}
|
|
10321
10636
|
const raw = match[0];
|
|
10322
10637
|
let buf;
|
|
10323
10638
|
if (kind === "base64") {
|
|
@@ -10340,37 +10655,47 @@ function* decodedCandidates(text, budget) {
|
|
|
10340
10655
|
}
|
|
10341
10656
|
}
|
|
10342
10657
|
}
|
|
10343
|
-
function
|
|
10658
|
+
function secretViews(text, budget) {
|
|
10344
10659
|
const seen = /* @__PURE__ */ new Set([text]);
|
|
10345
|
-
const
|
|
10346
|
-
|
|
10347
|
-
|
|
10348
|
-
|
|
10349
|
-
for (const
|
|
10350
|
-
|
|
10351
|
-
|
|
10352
|
-
|
|
10353
|
-
|
|
10354
|
-
|
|
10355
|
-
|
|
10356
|
-
|
|
10357
|
-
|
|
10358
|
-
|
|
10660
|
+
const out = [];
|
|
10661
|
+
let frontier = [{ text, transforms: [] }];
|
|
10662
|
+
for (let depth = 1; depth <= SECRET_VIEW_LIMITS.maxDepth; depth++) {
|
|
10663
|
+
const next = [];
|
|
10664
|
+
for (const parent of frontier) {
|
|
10665
|
+
let perLeaf = 0;
|
|
10666
|
+
for (const [kind, decoded] of decodedCandidates(parent.text, budget)) {
|
|
10667
|
+
if (seen.has(decoded)) continue;
|
|
10668
|
+
seen.add(decoded);
|
|
10669
|
+
const normalizing = kind === "invisibles" || kind === "percent";
|
|
10670
|
+
if (depth >= 2 && !normalizing) {
|
|
10671
|
+
budget.nestedBytes += Buffer.byteLength(decoded);
|
|
10672
|
+
if (++perLeaf > SECRET_VIEW_LIMITS.maxNestedViewsPerLeaf || budget.nestedBytes > SECRET_VIEW_LIMITS.maxNestedBytes) {
|
|
10673
|
+
budget.reasons.add("decode-nested");
|
|
10674
|
+
return out;
|
|
10675
|
+
}
|
|
10676
|
+
}
|
|
10677
|
+
const view = { text: decoded, transforms: [...parent.transforms, kind] };
|
|
10678
|
+
out.push(view);
|
|
10679
|
+
next.push(view);
|
|
10359
10680
|
}
|
|
10360
|
-
seen.add(decoded);
|
|
10361
|
-
budget.views++;
|
|
10362
|
-
budget.bytes += bytes;
|
|
10363
|
-
queue.push({ text: decoded, transforms: [...view.transforms, kind] });
|
|
10364
10681
|
}
|
|
10365
|
-
|
|
10682
|
+
frontier = next;
|
|
10683
|
+
if (!frontier.length) return out;
|
|
10366
10684
|
}
|
|
10685
|
+
for (const view of frontier) {
|
|
10686
|
+
if (!decodedCandidates(view.text, budget).next().done) {
|
|
10687
|
+
budget.reasons.add("decode-nested");
|
|
10688
|
+
break;
|
|
10689
|
+
}
|
|
10690
|
+
}
|
|
10691
|
+
return out;
|
|
10367
10692
|
}
|
|
10368
10693
|
|
|
10369
10694
|
// src/dlp/arguments.ts
|
|
10370
10695
|
var ARGUMENT_SCAN_LIMITS = {
|
|
10371
10696
|
maxDepth: 12,
|
|
10372
10697
|
maxNodes: 16384,
|
|
10373
|
-
/**
|
|
10698
|
+
/** Text is matched and decoded in windows of this size. */
|
|
10374
10699
|
maxStringCharacters: 1e5,
|
|
10375
10700
|
/** Windows overlap by this much so a token on a window edge is still seen whole. */
|
|
10376
10701
|
windowOverlap: 4096,
|
|
@@ -10380,17 +10705,46 @@ var ARGUMENT_SCAN_LIMITS = {
|
|
|
10380
10705
|
maxTailBytes: 4194304,
|
|
10381
10706
|
maxJsonCharacters: 1e4
|
|
10382
10707
|
};
|
|
10708
|
+
var RUN_CHAR = /[A-Za-z0-9+/=_%\\.-]/;
|
|
10709
|
+
var runChar = (value, index) => {
|
|
10710
|
+
const char = value[index] ?? "";
|
|
10711
|
+
return RUN_CHAR.test(char) || char !== "" && isInvisibleChar(char);
|
|
10712
|
+
};
|
|
10713
|
+
function batches(views) {
|
|
10714
|
+
const out = [];
|
|
10715
|
+
let current = [];
|
|
10716
|
+
let size = 0;
|
|
10717
|
+
for (const { text } of views) {
|
|
10718
|
+
if (current.length && size + text.length > SECRET_VIEW_LIMITS.batchCharacters) {
|
|
10719
|
+
out.push(current);
|
|
10720
|
+
current = [];
|
|
10721
|
+
size = 0;
|
|
10722
|
+
}
|
|
10723
|
+
current.push(text);
|
|
10724
|
+
size += text.length;
|
|
10725
|
+
}
|
|
10726
|
+
if (current.length) out.push(current);
|
|
10727
|
+
return out;
|
|
10728
|
+
}
|
|
10383
10729
|
function inspectArgumentSecrets(args) {
|
|
10384
|
-
const budget =
|
|
10730
|
+
const budget = newSecretViewBudget();
|
|
10385
10731
|
const ancestors = /* @__PURE__ */ new Set();
|
|
10386
10732
|
let nodes = 0;
|
|
10387
10733
|
let sourceBytes = 0;
|
|
10388
10734
|
let tailBytes = 0;
|
|
10389
10735
|
let best = null;
|
|
10736
|
+
const blocked = () => best?.severity === "block";
|
|
10390
10737
|
const accept = (match) => {
|
|
10391
10738
|
if (match && (!best || best.severity !== "block" && match.severity === "block")) best = match;
|
|
10392
10739
|
};
|
|
10740
|
+
const decodeSegment = (segment, fieldPath) => {
|
|
10741
|
+
for (const batch of batches(secretViews(segment, budget))) {
|
|
10742
|
+
accept(matchArgumentBatch(batch, fieldPath, budget));
|
|
10743
|
+
if (blocked()) return;
|
|
10744
|
+
}
|
|
10745
|
+
};
|
|
10393
10746
|
const visit = (value, depth, fieldPath) => {
|
|
10747
|
+
if (blocked()) return;
|
|
10394
10748
|
if (++nodes > ARGUMENT_SCAN_LIMITS.maxNodes) {
|
|
10395
10749
|
budget.reasons.add("argument-nodes");
|
|
10396
10750
|
return;
|
|
@@ -10432,14 +10786,11 @@ function inspectArgumentSecrets(args) {
|
|
|
10432
10786
|
}
|
|
10433
10787
|
sourceBytes += Math.min(bytes, Math.max(0, remaining));
|
|
10434
10788
|
if (!text) return;
|
|
10435
|
-
|
|
10436
|
-
|
|
10437
|
-
if (hit)
|
|
10438
|
-
accept(view.transforms.length ? { ...hit, redactedSample: "[encoded secret]" } : hit);
|
|
10439
|
-
}
|
|
10789
|
+
accept(matchArgumentText(text, fieldPath, budget));
|
|
10790
|
+
let scannedEnd = text.length;
|
|
10440
10791
|
if (!truncated && value.length > window) {
|
|
10441
|
-
budget.reasons.add("decode-window");
|
|
10442
10792
|
for (let start = window - overlap; start < value.length; start += window - overlap) {
|
|
10793
|
+
if (blocked()) return;
|
|
10443
10794
|
const chunk = value.slice(start, start + window);
|
|
10444
10795
|
const chunkBytes = Buffer.byteLength(chunk);
|
|
10445
10796
|
if (tailBytes + chunkBytes > ARGUMENT_SCAN_LIMITS.maxTailBytes) {
|
|
@@ -10448,9 +10799,16 @@ function inspectArgumentSecrets(args) {
|
|
|
10448
10799
|
}
|
|
10449
10800
|
tailBytes += chunkBytes;
|
|
10450
10801
|
accept(matchArgumentText(chunk, fieldPath, budget));
|
|
10802
|
+
scannedEnd = start + chunk.length;
|
|
10451
10803
|
if (start + window >= value.length) break;
|
|
10452
10804
|
}
|
|
10453
10805
|
}
|
|
10806
|
+
for (let start = 0; start < scannedEnd && !blocked(); ) {
|
|
10807
|
+
let end = Math.min(start + window, scannedEnd);
|
|
10808
|
+
while (end < scannedEnd && runChar(value, end - 1) && runChar(value, end)) end++;
|
|
10809
|
+
decodeSegment(value.slice(start, end), fieldPath);
|
|
10810
|
+
start = end;
|
|
10811
|
+
}
|
|
10454
10812
|
const trimmed = text.trim();
|
|
10455
10813
|
if (value.length < ARGUMENT_SCAN_LIMITS.maxJsonCharacters && (trimmed.startsWith("{") || trimmed.startsWith("["))) {
|
|
10456
10814
|
try {
|
|
@@ -10469,7 +10827,7 @@ function inspectArgumentSecrets(args) {
|
|
|
10469
10827
|
function scanArgumentSecrets(args) {
|
|
10470
10828
|
const result = inspectArgumentSecrets(args);
|
|
10471
10829
|
if (result.match) return result.match;
|
|
10472
|
-
return result.
|
|
10830
|
+
return result.coverage === "incomplete" ? {
|
|
10473
10831
|
patternName: "Argument inspection incomplete",
|
|
10474
10832
|
fieldPath: "args",
|
|
10475
10833
|
redactedSample: "[uninspected content]",
|
|
@@ -10504,18 +10862,13 @@ function tokenize2(toolName) {
|
|
|
10504
10862
|
return toolName.toLowerCase().split(/[_.\-\s]+/).filter(Boolean);
|
|
10505
10863
|
}
|
|
10506
10864
|
function extractShellCommand(toolName, args, toolInspection) {
|
|
10507
|
-
const
|
|
10508
|
-
|
|
10509
|
-
if (!matchingPattern) return null;
|
|
10510
|
-
const fieldPath = toolInspection[matchingPattern];
|
|
10865
|
+
const fieldPath = inspectionEntry(toolName, toolInspection);
|
|
10866
|
+
if (fieldPath === void 0) return null;
|
|
10511
10867
|
const value = getNestedValue(args, typeof fieldPath === "string" ? fieldPath : fieldPath.field);
|
|
10512
10868
|
return typeof value === "string" ? value : null;
|
|
10513
10869
|
}
|
|
10514
10870
|
function isSqlTool(toolName, toolInspection) {
|
|
10515
|
-
const
|
|
10516
|
-
const matchingPattern = patterns.find((p) => matchesPattern(toolName, p));
|
|
10517
|
-
if (!matchingPattern) return false;
|
|
10518
|
-
const fieldName = toolInspection[matchingPattern];
|
|
10871
|
+
const fieldName = inspectionEntry(toolName, toolInspection);
|
|
10519
10872
|
return fieldName === "sql" || fieldName === "query";
|
|
10520
10873
|
}
|
|
10521
10874
|
var SQL_DML_KEYWORDS = /* @__PURE__ */ new Set(["select", "insert", "update", "delete", "merge", "upsert"]);
|
|
@@ -10533,7 +10886,7 @@ function pipeChainVerdict(command, isTrustedHost, highAction = "review") {
|
|
|
10533
10886
|
if (!pipeAnalysis.isPipeline) return null;
|
|
10534
10887
|
if (pipeAnalysis.risk !== "critical" && pipeAnalysis.risk !== "high") return null;
|
|
10535
10888
|
const sinks = pipeAnalysis.sinkTargets;
|
|
10536
|
-
const allTrusted = sinks.length > 0 && sinks.every((
|
|
10889
|
+
const allTrusted = sinks.length > 0 && sinks.every((host2) => isTrustedHost ? isTrustedHost(host2) : false);
|
|
10537
10890
|
if (pipeAnalysis.risk === "critical") {
|
|
10538
10891
|
if (allTrusted) {
|
|
10539
10892
|
return {
|
|
@@ -10592,9 +10945,10 @@ function egressPolicyVerdict(eg) {
|
|
|
10592
10945
|
}
|
|
10593
10946
|
async function evaluatePolicy(config, toolName, args, context = {}, hooks = {}) {
|
|
10594
10947
|
let protectedVerdict = null;
|
|
10948
|
+
const layers = inspectionLayers(config.policy);
|
|
10595
10949
|
if (context.agent !== "Terminal") {
|
|
10596
10950
|
try {
|
|
10597
|
-
const accesses = context.accesses ?? collectFileAccesses(toolName, args, context,
|
|
10951
|
+
const accesses = context.accesses ?? collectFileAccesses(toolName, args, context, layers);
|
|
10598
10952
|
protectedVerdict = evaluateProtectedFileAccess(accesses, context, catalogSettings(config));
|
|
10599
10953
|
} catch {
|
|
10600
10954
|
protectedVerdict = incompleteFileVerdict();
|
|
@@ -10629,7 +10983,7 @@ async function evaluatePolicy(config, toolName, args, context = {}, hooks = {})
|
|
|
10629
10983
|
hooks
|
|
10630
10984
|
);
|
|
10631
10985
|
if (result.decision === "block") return result;
|
|
10632
|
-
if (context.agent !== "Terminal" && resolveShellInput(toolName, args,
|
|
10986
|
+
if (context.agent !== "Terminal" && resolveShellInput(toolName, args, layers).kind === "uninspectable") {
|
|
10633
10987
|
return {
|
|
10634
10988
|
decision: "review",
|
|
10635
10989
|
ruleName: "shell-inspection-incomplete",
|
|
@@ -10645,13 +10999,14 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10645
10999
|
const { agent, cwd, activeEnvironment } = context;
|
|
10646
11000
|
const { checkProvenance, isTrustedHost } = hooks;
|
|
10647
11001
|
const settingsView = catalogSettings(config);
|
|
11002
|
+
const layers = inspectionLayers(config.policy);
|
|
10648
11003
|
const cv = (id) => checkValue(settingsView, id);
|
|
10649
11004
|
let loggedFinding;
|
|
10650
11005
|
const noteLogged = (v) => {
|
|
10651
11006
|
if (v?.logged && !loggedFinding) loggedFinding = v;
|
|
10652
11007
|
};
|
|
10653
11008
|
const allowed = () => loggedFinding ?? { decision: "allow" };
|
|
10654
|
-
const shellInput = resolveShellInput(toolName, args,
|
|
11009
|
+
const shellInput = resolveShellInput(toolName, args, layers);
|
|
10655
11010
|
const wouldBeIgnored = matchesPattern(toolName, config.policy.ignoredTools);
|
|
10656
11011
|
{
|
|
10657
11012
|
const dest = ssrfDestinationFloor(toolName, args, {
|
|
@@ -10756,13 +11111,10 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10756
11111
|
return { id, value: cv(id) };
|
|
10757
11112
|
};
|
|
10758
11113
|
const matches = config.policy.smartRules.filter((rule) => {
|
|
10759
|
-
if (!toolMatchesRule(toolName, rule.tool,
|
|
11114
|
+
if (!toolMatchesRule(toolName, rule.tool, layers)) return false;
|
|
10760
11115
|
if (astSuppressed(rule)) return false;
|
|
10761
11116
|
if (rmCleanupWaiver && rule.name === "review-rm" && rule.verdict === "review") return false;
|
|
10762
|
-
if (!evaluateSmartConditions(
|
|
10763
|
-
shellRuleArgs(toolName, args, rule.tool, config.policy.toolInspection),
|
|
10764
|
-
rule
|
|
10765
|
-
))
|
|
11117
|
+
if (!evaluateSmartConditions(shellRuleArgs(toolName, args, rule.tool, layers), rule))
|
|
10766
11118
|
return false;
|
|
10767
11119
|
const check = ruleCheck(rule);
|
|
10768
11120
|
if (check?.value === "off") return false;
|
|
@@ -10809,7 +11161,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10809
11161
|
let allTokens = [];
|
|
10810
11162
|
let pathTokens = [];
|
|
10811
11163
|
if (pendingToolEgress) return pendingToolEgress;
|
|
10812
|
-
const shellCommand = shellInput.kind === "shell" ? shellInput.command : shellInput.kind === "not-shell" ? extractShellCommand(toolName, args,
|
|
11164
|
+
const shellCommand = shellInput.kind === "shell" ? shellInput.command : shellInput.kind === "not-shell" ? extractShellCommand(toolName, args, layers) : null;
|
|
10813
11165
|
if (shellCommand) {
|
|
10814
11166
|
const analyzed = analyzeShellCommand(shellCommand);
|
|
10815
11167
|
allTokens = analyzed.allTokens;
|
|
@@ -10886,7 +11238,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10886
11238
|
if (["ssh", "scp", "rsync"].includes(firstToken)) {
|
|
10887
11239
|
const rawTokens = shellCommand.trim().split(/\s+/);
|
|
10888
11240
|
const sshHosts = extractAllSshHosts(rawTokens.slice(1));
|
|
10889
|
-
allTokens.
|
|
11241
|
+
allTokens = allTokens.concat(sshHosts);
|
|
10890
11242
|
}
|
|
10891
11243
|
if (firstToken && firstToken.startsWith("/") && checkProvenance) {
|
|
10892
11244
|
const prov = checkProvenance(firstToken, cwd);
|
|
@@ -10915,7 +11267,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10915
11267
|
};
|
|
10916
11268
|
}
|
|
10917
11269
|
}
|
|
10918
|
-
if (isSqlTool(toolName,
|
|
11270
|
+
if (isSqlTool(toolName, layers)) {
|
|
10919
11271
|
allTokens = allTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
|
|
10920
11272
|
}
|
|
10921
11273
|
} else {
|
|
@@ -10923,7 +11275,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10923
11275
|
if (args && typeof args === "object") {
|
|
10924
11276
|
const flattenedArgs = JSON.stringify(args).toLowerCase();
|
|
10925
11277
|
const extraTokens = flattenedArgs.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 1);
|
|
10926
|
-
allTokens.
|
|
11278
|
+
allTokens = allTokens.concat(extraTokens);
|
|
10927
11279
|
}
|
|
10928
11280
|
}
|
|
10929
11281
|
const isManual = agent === "Terminal";
|
|
@@ -11011,6 +11363,638 @@ function isIgnoredTool(toolName, config) {
|
|
|
11011
11363
|
return matchesPattern(toolName, config.policy.ignoredTools);
|
|
11012
11364
|
}
|
|
11013
11365
|
|
|
11366
|
+
// src/exposure/destinations.ts
|
|
11367
|
+
var MAX_DESTINATIONS = 200;
|
|
11368
|
+
var MAX_SCAN_CHARS = 1e5;
|
|
11369
|
+
var EMAIL_RE = /[\p{L}\p{N}._%+-]+@[\p{L}\p{N}](?:[\p{L}\p{N}-]*[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]*[\p{L}\p{N}])?)*\.\p{L}{2,}/gu;
|
|
11370
|
+
var URL_RE = /\b(?:[a-z][a-z0-9+.-]*:\/\/|www\.)[^\s<>"'`){}]+/gi;
|
|
11371
|
+
var IBAN_RE = /\b[A-Z]{2}\d{2}(?:[ -]?[A-Z0-9]{4}){2,7}(?:[ -]?[A-Z0-9]{1,4})?\b/g;
|
|
11372
|
+
var RECIPIENT_KEYS = /* @__PURE__ */ new Set([
|
|
11373
|
+
"to",
|
|
11374
|
+
"cc",
|
|
11375
|
+
"bcc",
|
|
11376
|
+
"recipient",
|
|
11377
|
+
"recipients",
|
|
11378
|
+
"email",
|
|
11379
|
+
"participants",
|
|
11380
|
+
"attendees",
|
|
11381
|
+
"destination",
|
|
11382
|
+
"iban",
|
|
11383
|
+
"account",
|
|
11384
|
+
// Where a request goes, when the value is a bare host or a scheme-less URL.
|
|
11385
|
+
"url",
|
|
11386
|
+
"uri",
|
|
11387
|
+
"host",
|
|
11388
|
+
"hostname",
|
|
11389
|
+
"endpoint",
|
|
11390
|
+
"server",
|
|
11391
|
+
"domain",
|
|
11392
|
+
"address",
|
|
11393
|
+
"webhook",
|
|
11394
|
+
"webhook_url",
|
|
11395
|
+
"callback",
|
|
11396
|
+
"callback_url",
|
|
11397
|
+
"target"
|
|
11398
|
+
]);
|
|
11399
|
+
function normalizeHost(raw) {
|
|
11400
|
+
let h = raw.trim().toLowerCase();
|
|
11401
|
+
if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
|
|
11402
|
+
if (!h || h === "localhost") return null;
|
|
11403
|
+
if (/^[0-9a-f:]+$/.test(h) && h.includes(":")) return h;
|
|
11404
|
+
if (!h.includes(".") || !/^[\p{L}\p{N}.-]+$/u.test(h)) return null;
|
|
11405
|
+
return h;
|
|
11406
|
+
}
|
|
11407
|
+
function hostOfUrl(value) {
|
|
11408
|
+
const v = value.replace(/[.,;:!?)\]}>'"`]+$/, "");
|
|
11409
|
+
try {
|
|
11410
|
+
const u = new URL(v.toLowerCase().startsWith("www.") ? `http://${v}` : v);
|
|
11411
|
+
return normalizeHost(u.hostname);
|
|
11412
|
+
} catch {
|
|
11413
|
+
return null;
|
|
11414
|
+
}
|
|
11415
|
+
}
|
|
11416
|
+
function addIbans(text, out) {
|
|
11417
|
+
for (const m of text.toUpperCase().matchAll(IBAN_RE)) {
|
|
11418
|
+
const compact = m[0].replace(/[ -]/g, "");
|
|
11419
|
+
if (validateIban(compact)) out.add(`iban:${compact}`);
|
|
11420
|
+
else if (/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(compact)) out.add(`account:${compact}`);
|
|
11421
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11422
|
+
}
|
|
11423
|
+
}
|
|
11424
|
+
function addEmails(text, out) {
|
|
11425
|
+
for (const m of text.matchAll(EMAIL_RE)) {
|
|
11426
|
+
out.add(`email:${m[0].toLowerCase()}`);
|
|
11427
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11428
|
+
}
|
|
11429
|
+
}
|
|
11430
|
+
function addUrlHosts(text, out) {
|
|
11431
|
+
for (const m of text.matchAll(URL_RE)) {
|
|
11432
|
+
const h = hostOfUrl(m[0]);
|
|
11433
|
+
if (h) out.add(`host:${h}`);
|
|
11434
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11435
|
+
}
|
|
11436
|
+
}
|
|
11437
|
+
function extractContentDestinations(text) {
|
|
11438
|
+
const out = /* @__PURE__ */ new Set();
|
|
11439
|
+
try {
|
|
11440
|
+
const t = text.length > MAX_SCAN_CHARS ? text.slice(0, MAX_SCAN_CHARS) : text;
|
|
11441
|
+
if (t.includes("@")) addEmails(t, out);
|
|
11442
|
+
if (out.size < MAX_DESTINATIONS) addUrlHosts(t, out);
|
|
11443
|
+
if (out.size < MAX_DESTINATIONS) addIbans(t, out);
|
|
11444
|
+
} catch {
|
|
11445
|
+
}
|
|
11446
|
+
return [...out];
|
|
11447
|
+
}
|
|
11448
|
+
function extractArgDestinations(args) {
|
|
11449
|
+
const out = /* @__PURE__ */ new Set();
|
|
11450
|
+
try {
|
|
11451
|
+
walk(args, void 0, out, 0);
|
|
11452
|
+
} catch {
|
|
11453
|
+
}
|
|
11454
|
+
return [...out];
|
|
11455
|
+
}
|
|
11456
|
+
function walk(value, key, out, depth) {
|
|
11457
|
+
if (out.size >= MAX_DESTINATIONS || depth > 12) return;
|
|
11458
|
+
if (typeof value === "string") {
|
|
11459
|
+
const s = value.length > MAX_SCAN_CHARS ? value.slice(0, MAX_SCAN_CHARS) : value;
|
|
11460
|
+
if (s.includes("@")) addEmails(s, out);
|
|
11461
|
+
addUrlHosts(s, out);
|
|
11462
|
+
addIbans(s, out);
|
|
11463
|
+
if (key && RECIPIENT_KEYS.has(key.toLowerCase()) && !/[\s@]/.test(s)) {
|
|
11464
|
+
const h = normalizeHost(
|
|
11465
|
+
s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/^\/\//, "").split(/[/?#]/)[0].replace(/:\d+$/, "")
|
|
11466
|
+
);
|
|
11467
|
+
if (h && (h.includes(":") || /\.\p{L}{2,}$/u.test(h))) out.add(`host:${h}`);
|
|
11468
|
+
const acct = s.replace(/[ .-]/g, "").toUpperCase();
|
|
11469
|
+
if (/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(acct) && !validateIban(acct))
|
|
11470
|
+
out.add(`account:${acct}`);
|
|
11471
|
+
}
|
|
11472
|
+
return;
|
|
11473
|
+
}
|
|
11474
|
+
if (Array.isArray(value)) {
|
|
11475
|
+
for (const v of value) walk(v, key, out, depth + 1);
|
|
11476
|
+
return;
|
|
11477
|
+
}
|
|
11478
|
+
if (value && typeof value === "object") {
|
|
11479
|
+
for (const [k, v] of Object.entries(value))
|
|
11480
|
+
walk(v, k, out, depth + 1);
|
|
11481
|
+
}
|
|
11482
|
+
}
|
|
11483
|
+
function destinationDomain(dest) {
|
|
11484
|
+
if (!dest.startsWith("email:")) return null;
|
|
11485
|
+
const at = dest.lastIndexOf("@");
|
|
11486
|
+
return at > 0 ? dest.slice(at + 1) : null;
|
|
11487
|
+
}
|
|
11488
|
+
function destinationKind(dest) {
|
|
11489
|
+
const i = dest.indexOf(":");
|
|
11490
|
+
const k = i > 0 ? dest.slice(0, i) : "";
|
|
11491
|
+
return k === "email" || k === "host" || k === "iban" || k === "account" ? k : null;
|
|
11492
|
+
}
|
|
11493
|
+
function destinationValue(dest) {
|
|
11494
|
+
const i = dest.indexOf(":");
|
|
11495
|
+
return i > 0 ? dest.slice(i + 1) : dest;
|
|
11496
|
+
}
|
|
11497
|
+
function isLoopbackHost(host2) {
|
|
11498
|
+
let h = host2.trim().toLowerCase();
|
|
11499
|
+
if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
|
|
11500
|
+
return h === "localhost" || h.endsWith(".localhost") || /^127(?:\.\d{1,3}){3}$/.test(h) || h === "::1" || h === "0:0:0:0:0:0:0:1" || h === "0.0.0.0";
|
|
11501
|
+
}
|
|
11502
|
+
function gitRepoPath(url) {
|
|
11503
|
+
const u = url.trim();
|
|
11504
|
+
if (!u) return null;
|
|
11505
|
+
let host2;
|
|
11506
|
+
let p;
|
|
11507
|
+
if (/^[a-z][a-z0-9+.-]*:\/\//i.test(u)) {
|
|
11508
|
+
try {
|
|
11509
|
+
const parsed = new URL(u);
|
|
11510
|
+
host2 = parsed.hostname.toLowerCase();
|
|
11511
|
+
p = decodeURIComponent(parsed.pathname);
|
|
11512
|
+
} catch {
|
|
11513
|
+
return null;
|
|
11514
|
+
}
|
|
11515
|
+
} else {
|
|
11516
|
+
const scp = /^(?:[^@/\s]+@)?([A-Za-z0-9.-]+):(?!\/\/)(.+)$/.exec(u);
|
|
11517
|
+
if (!scp || !scp[1].includes(".")) return null;
|
|
11518
|
+
host2 = scp[1].toLowerCase();
|
|
11519
|
+
p = scp[2];
|
|
11520
|
+
}
|
|
11521
|
+
let start = 0;
|
|
11522
|
+
let end = p.length;
|
|
11523
|
+
while (start < end && p[start] === "/") start++;
|
|
11524
|
+
while (end > start && p[end - 1] === "/") end--;
|
|
11525
|
+
const tail = p.slice(start, end).replace(/\.git$/i, "").toLowerCase();
|
|
11526
|
+
if (!host2 || !tail.includes("/")) return null;
|
|
11527
|
+
return `${host2}/${tail}`;
|
|
11528
|
+
}
|
|
11529
|
+
var DESTRUCTIVE_VERB_RE = /^(?:delete|remove|drop|destroy|purge|wipe|erase|transfer|pay|send_money|withdraw|change_password|update_password|reset_password|set_permission|grant|revoke|share)(?:_|$)/i;
|
|
11530
|
+
function isDestructiveToolName(bareTool) {
|
|
11531
|
+
return DESTRUCTIVE_VERB_RE.test(bareTool);
|
|
11532
|
+
}
|
|
11533
|
+
|
|
11534
|
+
// src/exposure/shell.ts
|
|
11535
|
+
var import_mvdan_sh4 = __toESM(require("mvdan-sh"));
|
|
11536
|
+
var { syntax: syntax4 } = import_mvdan_sh4.default;
|
|
11537
|
+
var EMPTY = {
|
|
11538
|
+
fetches: false,
|
|
11539
|
+
sends: false,
|
|
11540
|
+
destinations: [],
|
|
11541
|
+
gitRemotes: [],
|
|
11542
|
+
repos: [],
|
|
11543
|
+
unresolved: false,
|
|
11544
|
+
fetchDestinations: [],
|
|
11545
|
+
fetchKinds: []
|
|
11546
|
+
};
|
|
11547
|
+
var CURL_SEND_FLAGS = /* @__PURE__ */ new Set([
|
|
11548
|
+
"-d",
|
|
11549
|
+
"--data",
|
|
11550
|
+
"--data-ascii",
|
|
11551
|
+
"--data-binary",
|
|
11552
|
+
"--data-raw",
|
|
11553
|
+
"--data-urlencode",
|
|
11554
|
+
"-F",
|
|
11555
|
+
"--form",
|
|
11556
|
+
"--form-string",
|
|
11557
|
+
"-T",
|
|
11558
|
+
"--upload-file",
|
|
11559
|
+
"--json"
|
|
11560
|
+
]);
|
|
11561
|
+
var WGET_SEND_FLAGS = /* @__PURE__ */ new Set(["--post-data", "--post-file", "--body-data", "--body-file"]);
|
|
11562
|
+
var IWR_SEND_FLAGS = /* @__PURE__ */ new Set(["-body", "-infile"]);
|
|
11563
|
+
var WRITE_METHODS = /* @__PURE__ */ new Set(["post", "put", "patch", "delete"]);
|
|
11564
|
+
var GH_READ = /* @__PURE__ */ new Set(["view", "list", "diff", "checks", "status", "download", "clone"]);
|
|
11565
|
+
var GH_WRITE = /* @__PURE__ */ new Set([
|
|
11566
|
+
"create",
|
|
11567
|
+
"comment",
|
|
11568
|
+
"edit",
|
|
11569
|
+
"close",
|
|
11570
|
+
"reopen",
|
|
11571
|
+
"merge",
|
|
11572
|
+
"review",
|
|
11573
|
+
"upload",
|
|
11574
|
+
"delete",
|
|
11575
|
+
"transfer",
|
|
11576
|
+
"pin",
|
|
11577
|
+
"lock",
|
|
11578
|
+
"ready",
|
|
11579
|
+
"set",
|
|
11580
|
+
"sync",
|
|
11581
|
+
"fork"
|
|
11582
|
+
]);
|
|
11583
|
+
var GH_HOSTNAME_FLAGS = /* @__PURE__ */ new Set(["--hostname", "-h", "-R", "--repo"]);
|
|
11584
|
+
var GH_REPO_VALUE_FLAGS = /* @__PURE__ */ new Set([
|
|
11585
|
+
"--hostname",
|
|
11586
|
+
"-R",
|
|
11587
|
+
"--repo",
|
|
11588
|
+
"-d",
|
|
11589
|
+
"--description",
|
|
11590
|
+
"-h",
|
|
11591
|
+
"--homepage",
|
|
11592
|
+
"--visibility",
|
|
11593
|
+
"--default-branch",
|
|
11594
|
+
"--add-topic",
|
|
11595
|
+
"--remove-topic",
|
|
11596
|
+
"-p",
|
|
11597
|
+
"--template",
|
|
11598
|
+
"-s",
|
|
11599
|
+
"--source",
|
|
11600
|
+
"-b",
|
|
11601
|
+
"--branch",
|
|
11602
|
+
"-l",
|
|
11603
|
+
"--license",
|
|
11604
|
+
"-g",
|
|
11605
|
+
"--gitignore",
|
|
11606
|
+
"-t",
|
|
11607
|
+
"--team",
|
|
11608
|
+
"-r",
|
|
11609
|
+
"--remote",
|
|
11610
|
+
"--org"
|
|
11611
|
+
]);
|
|
11612
|
+
var GH_API_VALUE_FLAGS = /* @__PURE__ */ new Set([
|
|
11613
|
+
"--hostname",
|
|
11614
|
+
"-X",
|
|
11615
|
+
"--method",
|
|
11616
|
+
"-f",
|
|
11617
|
+
"--raw-field",
|
|
11618
|
+
"-F",
|
|
11619
|
+
"--field",
|
|
11620
|
+
"-H",
|
|
11621
|
+
"--header",
|
|
11622
|
+
"--input",
|
|
11623
|
+
"-q",
|
|
11624
|
+
"--jq",
|
|
11625
|
+
"-t",
|
|
11626
|
+
"--template",
|
|
11627
|
+
"--cache",
|
|
11628
|
+
"-p",
|
|
11629
|
+
"--preview"
|
|
11630
|
+
]);
|
|
11631
|
+
var GIT_FETCH = /* @__PURE__ */ new Set(["clone", "fetch", "pull", "ls-remote"]);
|
|
11632
|
+
var PUBLISH = {
|
|
11633
|
+
npm: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "registry.npmjs.org", flag: ["--registry"] },
|
|
11634
|
+
pnpm: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "registry.npmjs.org", flag: ["--registry"] },
|
|
11635
|
+
yarn: {
|
|
11636
|
+
verbs: /* @__PURE__ */ new Set(["publish", "npm"]),
|
|
11637
|
+
registry: "registry.npmjs.org",
|
|
11638
|
+
flag: ["--registry"]
|
|
11639
|
+
},
|
|
11640
|
+
twine: { verbs: /* @__PURE__ */ new Set(["upload"]), registry: "upload.pypi.org", flag: ["--repository-url"] },
|
|
11641
|
+
cargo: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "crates.io", flag: ["--registry", "--index"] },
|
|
11642
|
+
gem: { verbs: /* @__PURE__ */ new Set(["push"]), registry: "rubygems.org", flag: ["--host"] },
|
|
11643
|
+
docker: { verbs: /* @__PURE__ */ new Set(["push"]), registry: "docker.io" }
|
|
11644
|
+
};
|
|
11645
|
+
var SHELLS2 = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
|
|
11646
|
+
var OWN_HEADS = /* @__PURE__ */ new Set([...Object.keys(PUBLISH), "git", "gh"]);
|
|
11647
|
+
var MAX_DEPTH3 = 3;
|
|
11648
|
+
function host(token) {
|
|
11649
|
+
if (!token) return null;
|
|
11650
|
+
const h = parseDestHost(token);
|
|
11651
|
+
return h ? `host:${h}` : null;
|
|
11652
|
+
}
|
|
11653
|
+
var CWD_CHANGERS = /* @__PURE__ */ new Set(["cd", "pushd", "popd"]);
|
|
11654
|
+
function ghRepoArg(v, defaultHost) {
|
|
11655
|
+
if (/:\/\/|@/.test(v)) {
|
|
11656
|
+
const r = gitRepoPath(v);
|
|
11657
|
+
if (r) return { host: r.split("/")[0], repo: r };
|
|
11658
|
+
}
|
|
11659
|
+
const parts = v.toLowerCase().replace(/\.git$/, "").split("/").filter(Boolean);
|
|
11660
|
+
if (parts.length === 3) return { host: parts[0], repo: parts.join("/") };
|
|
11661
|
+
if (parts.length === 2) return { host: defaultHost, repo: `${defaultHost}/${parts.join("/")}` };
|
|
11662
|
+
return { host: defaultHost, repo: `${defaultHost}/*` };
|
|
11663
|
+
}
|
|
11664
|
+
function ghApiRepo(endpoint, ghHost) {
|
|
11665
|
+
if (endpoint === null) return `${ghHost}/*`;
|
|
11666
|
+
const e = endpoint.replace(/^https?:\/\/[^/]+\//i, "").replace(/^\/+/, "");
|
|
11667
|
+
const m = /^repos\/([^/]+)\/([^/?#]+)/i.exec(e);
|
|
11668
|
+
if (!m) return `${ghHost}/*`;
|
|
11669
|
+
if (m[1] === "{owner}" && m[2] === "{repo}") return void 0;
|
|
11670
|
+
return `${ghHost}/${m[1].toLowerCase()}/${m[2].toLowerCase()}`;
|
|
11671
|
+
}
|
|
11672
|
+
function sendToGitUrl(url, out) {
|
|
11673
|
+
out.sends = true;
|
|
11674
|
+
const h = typeof url === "string" ? host(url) : null;
|
|
11675
|
+
if (!url || !h) {
|
|
11676
|
+
out.unresolved = true;
|
|
11677
|
+
return;
|
|
11678
|
+
}
|
|
11679
|
+
out.destinations.push(h);
|
|
11680
|
+
const r = gitRepoPath(url);
|
|
11681
|
+
if (r) out.repos.push(r);
|
|
11682
|
+
}
|
|
11683
|
+
function callWords(call) {
|
|
11684
|
+
const raw = call.Args || [];
|
|
11685
|
+
if (raw.length === 0) return null;
|
|
11686
|
+
const words = raw.map((a) => resolveWordLiteral(a));
|
|
11687
|
+
const prefixes = raw.map((a) => resolveWordPrefix(a).prefix);
|
|
11688
|
+
const first = (words[0] || "").toLowerCase().split("/").pop() ?? "";
|
|
11689
|
+
const at = OWN_HEADS.has(first) ? 0 : unwrapCommandHead(words);
|
|
11690
|
+
const head = (words[at] || "").toLowerCase().split("/").pop() ?? "";
|
|
11691
|
+
if (!head) return null;
|
|
11692
|
+
const assigns = call.Assigns || [];
|
|
11693
|
+
const env = [
|
|
11694
|
+
...assigns.map((a) => String(a?.Name?.Value ?? "")),
|
|
11695
|
+
...words.slice(0, at).map((w) => w === null ? "" : /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(w)?.[1] ?? "")
|
|
11696
|
+
].filter(Boolean);
|
|
11697
|
+
return { head, args: words.slice(at + 1), prefixes: prefixes.slice(at + 1), env };
|
|
11698
|
+
}
|
|
11699
|
+
function flagValue(args, names) {
|
|
11700
|
+
for (let i = 0; i < args.length; i++) {
|
|
11701
|
+
const w = args[i];
|
|
11702
|
+
if (w === null) continue;
|
|
11703
|
+
for (const n of names) {
|
|
11704
|
+
if (w === n && typeof args[i + 1] === "string") return args[i + 1];
|
|
11705
|
+
if (w.startsWith(`${n}=`)) return w.slice(n.length + 1);
|
|
11706
|
+
}
|
|
11707
|
+
}
|
|
11708
|
+
return null;
|
|
11709
|
+
}
|
|
11710
|
+
function positionals(args, valueFlags) {
|
|
11711
|
+
const out = [];
|
|
11712
|
+
for (let i = 0; i < args.length; i++) {
|
|
11713
|
+
const w = args[i];
|
|
11714
|
+
if (w === null) {
|
|
11715
|
+
out.push(null);
|
|
11716
|
+
continue;
|
|
11717
|
+
}
|
|
11718
|
+
if (w === "--") {
|
|
11719
|
+
out.push(...args.slice(i + 1));
|
|
11720
|
+
break;
|
|
11721
|
+
}
|
|
11722
|
+
if (w.startsWith("-")) {
|
|
11723
|
+
if (!w.includes("=") && valueFlags.has(w)) i++;
|
|
11724
|
+
continue;
|
|
11725
|
+
}
|
|
11726
|
+
out.push(w);
|
|
11727
|
+
}
|
|
11728
|
+
return out;
|
|
11729
|
+
}
|
|
11730
|
+
function classifyCall(head, args, prefixes, env, state, out) {
|
|
11731
|
+
const lower2 = args.map((a) => a === null ? null : a.toLowerCase());
|
|
11732
|
+
switch (head) {
|
|
11733
|
+
case "curl":
|
|
11734
|
+
case "wget":
|
|
11735
|
+
case "iwr":
|
|
11736
|
+
case "invoke-webrequest":
|
|
11737
|
+
case "irm":
|
|
11738
|
+
case "invoke-restmethod": {
|
|
11739
|
+
const binary = head === "wget" ? "wget" : "curl";
|
|
11740
|
+
const sendFlags = head === "wget" ? WGET_SEND_FLAGS : head === "curl" ? CURL_SEND_FLAGS : IWR_SEND_FLAGS;
|
|
11741
|
+
let sends = false;
|
|
11742
|
+
for (let i = 0; i < args.length; i++) {
|
|
11743
|
+
const w = args[i];
|
|
11744
|
+
if (w === null) continue;
|
|
11745
|
+
const name = (head === "curl" || head === "wget" ? w : w.toLowerCase()).split("=")[0];
|
|
11746
|
+
if (sendFlags.has(name)) sends = true;
|
|
11747
|
+
const next = lower2[i + 1];
|
|
11748
|
+
if ((name === "-X" || name === "--request" || name === "-method") && next) {
|
|
11749
|
+
if (WRITE_METHODS.has(next)) sends = true;
|
|
11750
|
+
}
|
|
11751
|
+
if (/^(?:--request=|-X)(POST|PUT|PATCH|DELETE)$/i.test(w)) sends = true;
|
|
11752
|
+
if (name === "--method" && next && WRITE_METHODS.has(next)) sends = true;
|
|
11753
|
+
}
|
|
11754
|
+
const withPrefixes = args.map(
|
|
11755
|
+
(a, i) => a === null && /^[a-z][a-z0-9+.-]*:\/\//i.test(prefixes[i] ?? "") ? prefixes[i] : a
|
|
11756
|
+
);
|
|
11757
|
+
const dests = destTokensForBinary(binary, withPrefixes).map((t) => host(t)).filter((h) => h !== null);
|
|
11758
|
+
out.fetches = true;
|
|
11759
|
+
out.fetchKinds.push(head);
|
|
11760
|
+
out.fetchDestinations.push(...dests);
|
|
11761
|
+
if (sends) {
|
|
11762
|
+
out.sends = true;
|
|
11763
|
+
out.destinations.push(...dests);
|
|
11764
|
+
}
|
|
11765
|
+
return;
|
|
11766
|
+
}
|
|
11767
|
+
case "scp":
|
|
11768
|
+
case "rsync": {
|
|
11769
|
+
const pos = positionals(args, VALUE_FLAGS[head] ?? /* @__PURE__ */ new Set()).filter(
|
|
11770
|
+
(p) => p !== null
|
|
11771
|
+
);
|
|
11772
|
+
if (pos.length < 2) return;
|
|
11773
|
+
const remote = (p) => /^[a-z][a-z0-9+.-]*:\/\//i.test(p) || /^[^/]*[^/:]:[^/]/.test(p) || p.includes("@");
|
|
11774
|
+
const target = pos[pos.length - 1];
|
|
11775
|
+
const sources = pos.slice(0, -1);
|
|
11776
|
+
if (remote(target)) {
|
|
11777
|
+
out.sends = true;
|
|
11778
|
+
const h = host(target);
|
|
11779
|
+
if (h) out.destinations.push(h);
|
|
11780
|
+
}
|
|
11781
|
+
if (sources.some(remote)) {
|
|
11782
|
+
out.fetches = true;
|
|
11783
|
+
out.fetchKinds.push(head);
|
|
11784
|
+
for (const src of sources.filter(remote)) {
|
|
11785
|
+
const h = host(src);
|
|
11786
|
+
if (h) out.fetchDestinations.push(h);
|
|
11787
|
+
}
|
|
11788
|
+
}
|
|
11789
|
+
return;
|
|
11790
|
+
}
|
|
11791
|
+
case "nc":
|
|
11792
|
+
case "ncat":
|
|
11793
|
+
case "netcat":
|
|
11794
|
+
case "ssh": {
|
|
11795
|
+
out.fetches = true;
|
|
11796
|
+
out.sends = true;
|
|
11797
|
+
out.fetchKinds.push(head);
|
|
11798
|
+
for (const t of destTokensForBinary(head, args)) {
|
|
11799
|
+
const h = host(t);
|
|
11800
|
+
if (h) {
|
|
11801
|
+
out.destinations.push(h);
|
|
11802
|
+
out.fetchDestinations.push(h);
|
|
11803
|
+
}
|
|
11804
|
+
}
|
|
11805
|
+
return;
|
|
11806
|
+
}
|
|
11807
|
+
case "gh": {
|
|
11808
|
+
const pos = positionals(args, GH_HOSTNAME_FLAGS);
|
|
11809
|
+
const group = pos[0] ?? null;
|
|
11810
|
+
const verb = pos[1] ?? null;
|
|
11811
|
+
const hn = flagValue(args, ["--hostname"]);
|
|
11812
|
+
let dest = host(hn ?? "github.com") ?? "host:github.com";
|
|
11813
|
+
const ghHost = dest.slice("host:".length);
|
|
11814
|
+
const envRepo = env.some((n) => n === "GH_REPO" || n === "GH_HOST");
|
|
11815
|
+
if (group === "api") {
|
|
11816
|
+
const method = (flagValue(args, ["-X", "--method"]) ?? "get").toLowerCase();
|
|
11817
|
+
const hasBody = args.some(
|
|
11818
|
+
(w) => w !== null && /^(-f|--raw-field|-F|--field|--input)(=|$)/.test(w)
|
|
11819
|
+
);
|
|
11820
|
+
if (WRITE_METHODS.has(method) || hasBody) {
|
|
11821
|
+
out.sends = true;
|
|
11822
|
+
out.destinations.push(dest);
|
|
11823
|
+
const endpoint = positionals(args, GH_API_VALUE_FLAGS)[1] ?? null;
|
|
11824
|
+
const repo = ghApiRepo(endpoint, ghHost);
|
|
11825
|
+
if (repo !== void 0) out.repos.push(repo);
|
|
11826
|
+
else if (envRepo) out.repos.push(`${ghHost}/*`);
|
|
11827
|
+
} else {
|
|
11828
|
+
out.fetches = true;
|
|
11829
|
+
out.fetchKinds.push("gh api");
|
|
11830
|
+
out.fetchDestinations.push(dest);
|
|
11831
|
+
}
|
|
11832
|
+
return;
|
|
11833
|
+
}
|
|
11834
|
+
if (group === null || verb === null) return;
|
|
11835
|
+
if (GH_WRITE.has(verb)) {
|
|
11836
|
+
out.sends = true;
|
|
11837
|
+
const rIdx = args.findIndex((w) => w === "-R" || w === "--repo");
|
|
11838
|
+
const rEq = args.find((w) => w !== null && /^(-R|--repo)=/.test(w));
|
|
11839
|
+
const rVal = rEq !== void 0 && rEq !== null ? rEq.slice(rEq.indexOf("=") + 1) : rIdx >= 0 ? args[rIdx + 1] : void 0;
|
|
11840
|
+
let repo;
|
|
11841
|
+
if (rIdx >= 0 || rEq !== void 0) {
|
|
11842
|
+
if (typeof rVal === "string") {
|
|
11843
|
+
const named = ghRepoArg(rVal, ghHost);
|
|
11844
|
+
repo = named.repo;
|
|
11845
|
+
if (named.host !== ghHost) dest = `host:${named.host}`;
|
|
11846
|
+
} else repo = `${ghHost}/*`;
|
|
11847
|
+
} else if (group === "gist" || group === "repo" && (verb === "create" || verb === "fork")) {
|
|
11848
|
+
repo = `${ghHost}/*`;
|
|
11849
|
+
} else if (group === "repo" && verb !== "rename") {
|
|
11850
|
+
const operand = positionals(args, GH_REPO_VALUE_FLAGS)[2];
|
|
11851
|
+
if (operand === null) repo = `${ghHost}/*`;
|
|
11852
|
+
else if (operand !== void 0) repo = ghRepoArg(operand, ghHost).repo;
|
|
11853
|
+
else if (envRepo) repo = `${ghHost}/*`;
|
|
11854
|
+
} else if (envRepo) {
|
|
11855
|
+
repo = `${ghHost}/*`;
|
|
11856
|
+
}
|
|
11857
|
+
out.destinations.push(dest);
|
|
11858
|
+
if (repo !== void 0) out.repos.push(repo);
|
|
11859
|
+
} else if (GH_READ.has(verb)) {
|
|
11860
|
+
out.fetches = true;
|
|
11861
|
+
out.fetchKinds.push(`gh ${group}`);
|
|
11862
|
+
out.fetchDestinations.push(dest);
|
|
11863
|
+
}
|
|
11864
|
+
return;
|
|
11865
|
+
}
|
|
11866
|
+
case "git": {
|
|
11867
|
+
const pos = positionals(args, /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree"]));
|
|
11868
|
+
const verb = pos[0];
|
|
11869
|
+
if (verb === null || verb === void 0) return;
|
|
11870
|
+
for (let i = 0; i < args.length; i++) {
|
|
11871
|
+
if (args[i] !== "-c") continue;
|
|
11872
|
+
const v = args[i + 1];
|
|
11873
|
+
if (v === null || v === void 0) {
|
|
11874
|
+
if (verb === "push") out.unresolved = true;
|
|
11875
|
+
continue;
|
|
11876
|
+
}
|
|
11877
|
+
const m = /^remote\.[^=]+\.(?:push)?url=(.*)$/i.exec(v);
|
|
11878
|
+
if (m) sendToGitUrl(m[1], out);
|
|
11879
|
+
}
|
|
11880
|
+
if (verb === "remote") {
|
|
11881
|
+
const rp = positionals(args, /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "-t", "-m"]));
|
|
11882
|
+
const sub = rp[1];
|
|
11883
|
+
if (sub === "add" || sub === "set-url") {
|
|
11884
|
+
const url = rp.slice(2).filter((p) => p !== "--push" && p !== "--add")[1];
|
|
11885
|
+
sendToGitUrl(url, out);
|
|
11886
|
+
}
|
|
11887
|
+
return;
|
|
11888
|
+
}
|
|
11889
|
+
if (verb === "config") {
|
|
11890
|
+
const reads = args.some(
|
|
11891
|
+
(w) => w !== null && /^--(get|get-all|get-regexp|unset|unset-all|list|get-urlmatch)$/.test(w)
|
|
11892
|
+
);
|
|
11893
|
+
const k = pos.findIndex((p) => p !== null && /^remote\..+\.(?:push)?url$/i.test(p));
|
|
11894
|
+
if (k >= 0 && k + 1 < pos.length && !reads) sendToGitUrl(pos[k + 1], out);
|
|
11895
|
+
return;
|
|
11896
|
+
}
|
|
11897
|
+
if (GIT_FETCH.has(verb)) {
|
|
11898
|
+
out.fetches = true;
|
|
11899
|
+
out.fetchKinds.push(`git ${verb}`);
|
|
11900
|
+
for (const p of pos.slice(1)) {
|
|
11901
|
+
const h = p !== null && /:\/\/|@/.test(p) ? host(p) : null;
|
|
11902
|
+
if (h) out.fetchDestinations.push(h);
|
|
11903
|
+
}
|
|
11904
|
+
return;
|
|
11905
|
+
}
|
|
11906
|
+
if (verb === "push") {
|
|
11907
|
+
if (pos.length > 1 && pos[1] === null) {
|
|
11908
|
+
out.sends = true;
|
|
11909
|
+
out.unresolved = true;
|
|
11910
|
+
return;
|
|
11911
|
+
}
|
|
11912
|
+
const target = flagValue(args, ["--repo"]) ?? pos.slice(1).find((p) => p !== null && !p.startsWith("-")) ?? null;
|
|
11913
|
+
if (target !== null && (/:\/\/|@/.test(target) || /^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+:/.test(target))) {
|
|
11914
|
+
sendToGitUrl(target, out);
|
|
11915
|
+
return;
|
|
11916
|
+
}
|
|
11917
|
+
if (target !== null && /^[./~]|\//.test(target)) return;
|
|
11918
|
+
out.sends = true;
|
|
11919
|
+
const elsewhere = state.cwdChanged || args.some((w) => w !== null && /^(-C|--git-dir|--work-tree)(=|$)/.test(w)) || env.some((n) => n === "GIT_DIR" || n === "GIT_WORK_TREE" || n === "GIT_CONFIG");
|
|
11920
|
+
if (elsewhere) out.unresolved = true;
|
|
11921
|
+
else out.gitRemotes.push(target ?? "");
|
|
11922
|
+
}
|
|
11923
|
+
return;
|
|
11924
|
+
}
|
|
11925
|
+
default: {
|
|
11926
|
+
const pub = PUBLISH[head];
|
|
11927
|
+
if (!pub) return;
|
|
11928
|
+
const pos = positionals(args, new Set(pub.flag ?? []));
|
|
11929
|
+
const verb = pos[0];
|
|
11930
|
+
if (verb === null || verb === void 0 || !pub.verbs.has(verb)) return;
|
|
11931
|
+
if (head === "yarn" && verb === "npm" && pos[1] !== "publish") return;
|
|
11932
|
+
out.sends = true;
|
|
11933
|
+
const named = pub.flag ? flagValue(args, pub.flag) : null;
|
|
11934
|
+
const h = named ? host(named) : null;
|
|
11935
|
+
if (named && !h) return;
|
|
11936
|
+
if (head === "docker") {
|
|
11937
|
+
const image = pos[1];
|
|
11938
|
+
const first = image?.split("/")[0] ?? "";
|
|
11939
|
+
const reg = first.includes(".") || first.includes(":") ? host(first) : null;
|
|
11940
|
+
out.destinations.push(reg ?? "host:docker.io");
|
|
11941
|
+
return;
|
|
11942
|
+
}
|
|
11943
|
+
out.destinations.push(h ?? `host:${pub.registry}`);
|
|
11944
|
+
}
|
|
11945
|
+
}
|
|
11946
|
+
}
|
|
11947
|
+
function walkCalls(command, out, depth, state) {
|
|
11948
|
+
const f = parseShared(command);
|
|
11949
|
+
if (typeof f === "symbol" || !f) return;
|
|
11950
|
+
syntax4.Walk(f, (node) => {
|
|
11951
|
+
if (!node) return false;
|
|
11952
|
+
const type = syntax4.NodeType(node);
|
|
11953
|
+
if (type === "DeclClause") {
|
|
11954
|
+
for (const a of node.Args || []) if (a?.Name?.Value) state.env.add(a.Name.Value);
|
|
11955
|
+
return true;
|
|
11956
|
+
}
|
|
11957
|
+
if (type !== "CallExpr") return true;
|
|
11958
|
+
const call = node;
|
|
11959
|
+
if ((call.Args || []).length === 0) {
|
|
11960
|
+
for (const a of call.Assigns || []) if (a?.Name?.Value) state.env.add(a.Name.Value);
|
|
11961
|
+
return true;
|
|
11962
|
+
}
|
|
11963
|
+
const c = callWords(node);
|
|
11964
|
+
if (!c) return true;
|
|
11965
|
+
if (SHELLS2.has(c.head) && depth < MAX_DEPTH3) {
|
|
11966
|
+
const i = c.args.findIndex((w) => w === "-c" || w === "-lc" || w === "-ec");
|
|
11967
|
+
const payload = i >= 0 ? c.args[i + 1] : null;
|
|
11968
|
+
if (typeof payload === "string") walkCalls(payload, out, depth + 1, state);
|
|
11969
|
+
return true;
|
|
11970
|
+
}
|
|
11971
|
+
if (CWD_CHANGERS.has(c.head)) state.cwdChanged = true;
|
|
11972
|
+
classifyCall(c.head, c.args, c.prefixes, [...c.env, ...state.env], state, out);
|
|
11973
|
+
return true;
|
|
11974
|
+
});
|
|
11975
|
+
}
|
|
11976
|
+
function classifyShellExposure(command) {
|
|
11977
|
+
const out = {
|
|
11978
|
+
...EMPTY,
|
|
11979
|
+
destinations: [],
|
|
11980
|
+
gitRemotes: [],
|
|
11981
|
+
repos: [],
|
|
11982
|
+
fetchDestinations: [],
|
|
11983
|
+
fetchKinds: []
|
|
11984
|
+
};
|
|
11985
|
+
try {
|
|
11986
|
+
walkCalls(command, out, 0, { cwdChanged: false, env: /* @__PURE__ */ new Set() });
|
|
11987
|
+
} catch {
|
|
11988
|
+
return { ...EMPTY };
|
|
11989
|
+
}
|
|
11990
|
+
out.destinations = [...new Set(out.destinations)];
|
|
11991
|
+
out.fetchDestinations = [...new Set(out.fetchDestinations)];
|
|
11992
|
+
out.gitRemotes = [...new Set(out.gitRemotes)];
|
|
11993
|
+
out.repos = [...new Set(out.repos)];
|
|
11994
|
+
out.fetchKinds = [...new Set(out.fetchKinds)];
|
|
11995
|
+
return out;
|
|
11996
|
+
}
|
|
11997
|
+
|
|
11014
11998
|
// src/utils/safe-text.ts
|
|
11015
11999
|
var TERMINAL_ESCAPE_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-_]|[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
|
|
11016
12000
|
var CONTROL_CHAR_RE = /[\x00-\x1F\x7F]/g;
|
|
@@ -11411,7 +12395,7 @@ function detectArgsPii(args) {
|
|
|
11411
12395
|
// src/dlp/canary.ts
|
|
11412
12396
|
var CANARY_MIN_LENGTH = 16;
|
|
11413
12397
|
var MAX_TEXT = 1e5;
|
|
11414
|
-
var
|
|
12398
|
+
var MAX_DEPTH4 = 6;
|
|
11415
12399
|
var MAX_JSON_PARSE = 1e4;
|
|
11416
12400
|
var URL_DEPTH = 4;
|
|
11417
12401
|
var B64_DEPTH = 3;
|
|
@@ -11534,8 +12518,8 @@ function matchCanaryArgs(args, values) {
|
|
|
11534
12518
|
if (values.length === 0) return null;
|
|
11535
12519
|
const needles = prepare(values);
|
|
11536
12520
|
if (needles.length === 0) return null;
|
|
11537
|
-
const
|
|
11538
|
-
if (depth >
|
|
12521
|
+
const walk2 = (v, depth, fieldPath) => {
|
|
12522
|
+
if (depth > MAX_DEPTH4) return null;
|
|
11539
12523
|
if (typeof v === "string") {
|
|
11540
12524
|
const hit = matchPrepared(v, needles);
|
|
11541
12525
|
if (hit) return { id: hit.v.id, view: hit.view, fieldPath, retired: Boolean(hit.v.retired) };
|
|
@@ -11543,31 +12527,31 @@ function matchCanaryArgs(args, values) {
|
|
|
11543
12527
|
const trimmed = v.trim();
|
|
11544
12528
|
if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
|
|
11545
12529
|
try {
|
|
11546
|
-
return
|
|
12530
|
+
return walk2(JSON.parse(v), depth + 1, fieldPath);
|
|
11547
12531
|
} catch {
|
|
11548
12532
|
}
|
|
11549
12533
|
}
|
|
11550
12534
|
}
|
|
11551
12535
|
return null;
|
|
11552
12536
|
}
|
|
11553
|
-
if (typeof v === "number" && Number.isFinite(v)) return
|
|
12537
|
+
if (typeof v === "number" && Number.isFinite(v)) return walk2(String(v), depth, fieldPath);
|
|
11554
12538
|
if (Array.isArray(v)) {
|
|
11555
12539
|
for (let i = 0; i < v.length; i++) {
|
|
11556
|
-
const h =
|
|
12540
|
+
const h = walk2(v[i], depth + 1, `${fieldPath}[${i}]`);
|
|
11557
12541
|
if (h) return h;
|
|
11558
12542
|
}
|
|
11559
12543
|
return null;
|
|
11560
12544
|
}
|
|
11561
12545
|
if (v && typeof v === "object") {
|
|
11562
12546
|
for (const [k, child] of Object.entries(v)) {
|
|
11563
|
-
const h =
|
|
12547
|
+
const h = walk2(child, depth + 1, fieldPath ? `${fieldPath}.${k}` : k);
|
|
11564
12548
|
if (h) return h;
|
|
11565
12549
|
}
|
|
11566
12550
|
}
|
|
11567
12551
|
return null;
|
|
11568
12552
|
};
|
|
11569
12553
|
try {
|
|
11570
|
-
return
|
|
12554
|
+
return walk2(args, 0, "");
|
|
11571
12555
|
} catch (e) {
|
|
11572
12556
|
console.error(
|
|
11573
12557
|
"[node9 engine] canary args walk failed:",
|
|
@@ -11579,8 +12563,8 @@ function matchCanaryArgs(args, values) {
|
|
|
11579
12563
|
|
|
11580
12564
|
// src/scan/canonical.ts
|
|
11581
12565
|
var LONG_OUTPUT_THRESHOLD_BYTES = 100 * 1024;
|
|
11582
|
-
var CANONICAL_EXTRACTOR_VERSION = "canonical-
|
|
11583
|
-
var CANONICAL_EXTRACTOR_HASH = "
|
|
12566
|
+
var CANONICAL_EXTRACTOR_VERSION = "canonical-v26";
|
|
12567
|
+
var CANONICAL_EXTRACTOR_HASH = "dec8c65145686360";
|
|
11584
12568
|
var DEDUPE_PREVIEW_LEN = 120;
|
|
11585
12569
|
function extractCanonicalFindings(call, ctx) {
|
|
11586
12570
|
const out = [];
|
|
@@ -11951,6 +12935,8 @@ function* stringValues(obj, depth = 0) {
|
|
|
11951
12935
|
var ENGINE_VERSION = "1.4.0";
|
|
11952
12936
|
// Annotate the CommonJS export names for ESM import in node:
|
|
11953
12937
|
0 && (module.exports = {
|
|
12938
|
+
AGENT_INSTRUCTION_DIRS,
|
|
12939
|
+
AGENT_INSTRUCTION_FILES,
|
|
11954
12940
|
ARGUMENT_SCAN_LIMITS,
|
|
11955
12941
|
AST_FS_REGEX_RULES,
|
|
11956
12942
|
BASH_TOOL_NAMES,
|
|
@@ -11983,6 +12969,7 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
11983
12969
|
LOOP_THRESHOLD_FOR_WASTE,
|
|
11984
12970
|
MAP_GOVERNED,
|
|
11985
12971
|
MAX_BLAST_PATH,
|
|
12972
|
+
MAX_DESTINATIONS,
|
|
11986
12973
|
NET_BINARIES,
|
|
11987
12974
|
PATTERN_VERB_NAMES,
|
|
11988
12975
|
PRIVILEGE_ESCALATION_RE,
|
|
@@ -12009,6 +12996,7 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
12009
12996
|
classifyAuditEntry,
|
|
12010
12997
|
classifyRuleSeverity,
|
|
12011
12998
|
classifyScanSignal,
|
|
12999
|
+
classifyShellExposure,
|
|
12012
13000
|
classifySsrf,
|
|
12013
13001
|
collectFileAccesses,
|
|
12014
13002
|
computeAgentDeviceScore,
|
|
@@ -12020,6 +13008,9 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
12020
13008
|
decodeEmbeddedBase64,
|
|
12021
13009
|
decodeEmbeddedHex,
|
|
12022
13010
|
dedupeCanonicalFindings,
|
|
13011
|
+
destinationDomain,
|
|
13012
|
+
destinationKind,
|
|
13013
|
+
destinationValue,
|
|
12023
13014
|
detectArgsPii,
|
|
12024
13015
|
detectDangerousEval,
|
|
12025
13016
|
detectDangerousShellExec,
|
|
@@ -12031,7 +13022,9 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
12031
13022
|
evaluateProtectedFileAccess,
|
|
12032
13023
|
evaluateSmartConditions,
|
|
12033
13024
|
extractAllSshHosts,
|
|
13025
|
+
extractArgDestinations,
|
|
12034
13026
|
extractCanonicalFindings,
|
|
13027
|
+
extractContentDestinations,
|
|
12035
13028
|
extractNetworkTargets,
|
|
12036
13029
|
extractPackageInstalls,
|
|
12037
13030
|
extractPositionalArgs,
|
|
@@ -12045,14 +13038,21 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
12045
13038
|
getCheck,
|
|
12046
13039
|
getCompiledRegex,
|
|
12047
13040
|
getNestedValue,
|
|
13041
|
+
gitRepoPath,
|
|
12048
13042
|
hostMatches,
|
|
12049
13043
|
incompleteFileVerdict,
|
|
12050
13044
|
inspectArgumentSecrets,
|
|
13045
|
+
inspectionEntry,
|
|
13046
|
+
inspectionLayers,
|
|
13047
|
+
isAgentInstructionPath,
|
|
12051
13048
|
isBashTool,
|
|
13049
|
+
isDestructiveToolName,
|
|
12052
13050
|
isIgnoredTool,
|
|
13051
|
+
isInside,
|
|
12053
13052
|
isKnobGoverned,
|
|
12054
13053
|
isLegacySystemPath,
|
|
12055
13054
|
isLockedCheck,
|
|
13055
|
+
isLoopbackHost,
|
|
12056
13056
|
isPasswordHashPath,
|
|
12057
13057
|
isPrivateHost,
|
|
12058
13058
|
isProtectedHomePath,
|