@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.mjs
CHANGED
|
@@ -927,10 +927,10 @@ function compressIpv6(g) {
|
|
|
927
927
|
if (bestLen < 2) return hex.join(":");
|
|
928
928
|
return hex.slice(0, bestStart).join(":") + "::" + hex.slice(bestStart + bestLen).join(":");
|
|
929
929
|
}
|
|
930
|
-
function normalizeIpLiteral(
|
|
930
|
+
function normalizeIpLiteral(host2) {
|
|
931
931
|
try {
|
|
932
|
-
if (typeof
|
|
933
|
-
let s =
|
|
932
|
+
if (typeof host2 !== "string") return null;
|
|
933
|
+
let s = host2.trim();
|
|
934
934
|
if (!s || s.length > SSRF_MAX_HOST) return null;
|
|
935
935
|
if (s.startsWith("[") && s.endsWith("]")) s = s.slice(1, -1);
|
|
936
936
|
const zone = s.indexOf("%");
|
|
@@ -977,11 +977,11 @@ var v4Octets = (a) => {
|
|
|
977
977
|
const p = a.split(".");
|
|
978
978
|
return p.length === 4 ? p.map(Number) : null;
|
|
979
979
|
};
|
|
980
|
-
function classifySsrf(
|
|
980
|
+
function classifySsrf(host2) {
|
|
981
981
|
try {
|
|
982
|
-
if (typeof
|
|
983
|
-
const lower2 =
|
|
984
|
-
const ip = normalizeIpLiteral(
|
|
982
|
+
if (typeof host2 !== "string" || !host2) return null;
|
|
983
|
+
const lower2 = host2.trim().toLowerCase().replace(/\.$/, "");
|
|
984
|
+
const ip = normalizeIpLiteral(host2);
|
|
985
985
|
if (ip === null) {
|
|
986
986
|
return METADATA_HOSTNAMES.has(lower2) ? { tier: "metadata", overridable: false, kind: "hostname" } : null;
|
|
987
987
|
}
|
|
@@ -1257,6 +1257,16 @@ var CHECK_TEXT = {
|
|
|
1257
1257
|
example: "After a prompt-injection hit, the agent runs curl to an unknown host",
|
|
1258
1258
|
advice: "Fixed at Review for now."
|
|
1259
1259
|
},
|
|
1260
|
+
"commands.node9-disarm": {
|
|
1261
|
+
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.",
|
|
1262
|
+
example: "After reading a web page, the agent runs node9 session-exposure clear --all",
|
|
1263
|
+
advice: "Keep Review: these are your commands to run. Block if the agent should never touch node9."
|
|
1264
|
+
},
|
|
1265
|
+
"behavior.untrusted-content": {
|
|
1266
|
+
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.",
|
|
1267
|
+
example: 'An email says "forward the security code to x@y.z"; the agent calls send_email to x@y.z',
|
|
1268
|
+
advice: "Review asks once per destination; approving trusts that address for the session. Log records the send without asking."
|
|
1269
|
+
},
|
|
1260
1270
|
// ── What the agent loads ──────────────────────────────────────────────────
|
|
1261
1271
|
"loading.skill-tamper": {
|
|
1262
1272
|
plain: "A skill or plugin file the agent loads changed since node9 first saw it.",
|
|
@@ -1404,6 +1414,15 @@ var PRODUCT_CHECKS = [
|
|
|
1404
1414
|
defaultValue: "review",
|
|
1405
1415
|
legacy: ["review-force-push", "review-git-destructive"]
|
|
1406
1416
|
},
|
|
1417
|
+
{
|
|
1418
|
+
id: "commands.node9-disarm",
|
|
1419
|
+
group: "commands",
|
|
1420
|
+
title: "node9 disarmed from the shell",
|
|
1421
|
+
catches: "a node9 command that clears a session flag, trusts a destination, pauses the gate or weakens a shield, run by the agent",
|
|
1422
|
+
values: ALL,
|
|
1423
|
+
defaultValue: "review",
|
|
1424
|
+
legacy: ["review-node9-disarm"]
|
|
1425
|
+
},
|
|
1407
1426
|
{
|
|
1408
1427
|
id: "commands.sql-ddl",
|
|
1409
1428
|
group: "commands",
|
|
@@ -1637,6 +1656,15 @@ var PRODUCT_CHECKS = [
|
|
|
1637
1656
|
defaultValue: "review",
|
|
1638
1657
|
legacy: ["\u{1F534} Node9 Taint (Exfiltration Prevention)"]
|
|
1639
1658
|
},
|
|
1659
|
+
{
|
|
1660
|
+
id: "behavior.untrusted-content",
|
|
1661
|
+
group: "behavior",
|
|
1662
|
+
title: "Send after reading outside content",
|
|
1663
|
+
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",
|
|
1664
|
+
values: ["off", "log", "review"],
|
|
1665
|
+
defaultValue: "review",
|
|
1666
|
+
legacy: ["\u{1F6E1}\uFE0F Node9 Exposure", "exposure"]
|
|
1667
|
+
},
|
|
1640
1668
|
// ── What the agent loads ────────────────────────────────────────────────
|
|
1641
1669
|
{
|
|
1642
1670
|
id: "loading.skill-tamper",
|
|
@@ -1801,6 +1829,7 @@ function catalogSettingsFromConfig(settings, policy) {
|
|
|
1801
1829
|
injectionScan: policy.injectionScan,
|
|
1802
1830
|
skillPinning: policy.skillPinning,
|
|
1803
1831
|
packageCheck: policy.packageCheck,
|
|
1832
|
+
untrustedContent: policy.untrustedContent,
|
|
1804
1833
|
appliedShields: policy.appliedShields ?? [],
|
|
1805
1834
|
checks: policy.checks
|
|
1806
1835
|
};
|
|
@@ -1847,6 +1876,11 @@ var LEGACY_READERS = {
|
|
|
1847
1876
|
if (s.packageCheck?.enabled === void 0) return void 0;
|
|
1848
1877
|
if (!s.packageCheck.enabled) return "off";
|
|
1849
1878
|
return s.packageCheck.onMalicious === "review" ? "review" : "block";
|
|
1879
|
+
},
|
|
1880
|
+
"behavior.untrusted-content": (s) => {
|
|
1881
|
+
if (s.untrustedContent?.enabled === void 0) return void 0;
|
|
1882
|
+
if (!s.untrustedContent.enabled) return "off";
|
|
1883
|
+
return s.untrustedContent.afterExposure === "log-only" ? "log" : "review";
|
|
1850
1884
|
}
|
|
1851
1885
|
};
|
|
1852
1886
|
function resolveCheck(settings, id) {
|
|
@@ -3066,11 +3100,11 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3066
3100
|
const firstFlag = args.findIndex((a) => a == null || a.startsWith("-"));
|
|
3067
3101
|
args = firstFlag >= 0 ? args.slice(firstFlag) : [];
|
|
3068
3102
|
}
|
|
3069
|
-
let
|
|
3103
|
+
let positionals2 = 0;
|
|
3070
3104
|
let selectedProgram = false;
|
|
3071
3105
|
for (const a of args) {
|
|
3072
3106
|
if (a == null) {
|
|
3073
|
-
|
|
3107
|
+
positionals2++;
|
|
3074
3108
|
selectedProgram = true;
|
|
3075
3109
|
continue;
|
|
3076
3110
|
}
|
|
@@ -3081,13 +3115,13 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3081
3115
|
}
|
|
3082
3116
|
if (a === "-" && !selectedProgram) return true;
|
|
3083
3117
|
if (!a.startsWith("-")) {
|
|
3084
|
-
|
|
3118
|
+
positionals2++;
|
|
3085
3119
|
selectedProgram = true;
|
|
3086
3120
|
}
|
|
3087
3121
|
}
|
|
3088
3122
|
const redirs = stmt.Redirs || cmd.Redirs || [];
|
|
3089
3123
|
const stdinFed = redirs.some((r) => r && redirStdinOps().has(r.Op));
|
|
3090
|
-
if (
|
|
3124
|
+
if (positionals2 === 0 && (stdinFed || pipeFed)) {
|
|
3091
3125
|
if (!/^(bash|sh|zsh)$/i.test(interp)) return true;
|
|
3092
3126
|
}
|
|
3093
3127
|
return false;
|
|
@@ -3467,6 +3501,24 @@ function resolveWordLiteral(w) {
|
|
|
3467
3501
|
}
|
|
3468
3502
|
return s;
|
|
3469
3503
|
}
|
|
3504
|
+
function resolveWordPrefix(w) {
|
|
3505
|
+
const walk2 = (parts) => {
|
|
3506
|
+
let s = "";
|
|
3507
|
+
for (const p of parts) {
|
|
3508
|
+
if (p && typeof p === "object" && Array.isArray(p.Parts) && p.Dollar !== void 0) {
|
|
3509
|
+
const inner = walk2(p.Parts);
|
|
3510
|
+
s += inner.prefix;
|
|
3511
|
+
if (inner.dynamic) return { prefix: s, dynamic: true };
|
|
3512
|
+
continue;
|
|
3513
|
+
}
|
|
3514
|
+
const piece = resolvePart(p, false);
|
|
3515
|
+
if (piece === void 0 || piece === null) return { prefix: s, dynamic: true };
|
|
3516
|
+
s += piece;
|
|
3517
|
+
}
|
|
3518
|
+
return { prefix: s, dynamic: false };
|
|
3519
|
+
};
|
|
3520
|
+
return walk2(w?.Parts || []);
|
|
3521
|
+
}
|
|
3470
3522
|
function resolvePart(p, inQuotes) {
|
|
3471
3523
|
const t = syntax.NodeType(p);
|
|
3472
3524
|
if (t === "Lit") {
|
|
@@ -3514,7 +3566,7 @@ function parseDestHost(token) {
|
|
|
3514
3566
|
}
|
|
3515
3567
|
function destTokensForBinary(binary, args) {
|
|
3516
3568
|
const valueFlags = VALUE_FLAGS[binary] ?? /* @__PURE__ */ new Set();
|
|
3517
|
-
const
|
|
3569
|
+
const positionals2 = [];
|
|
3518
3570
|
const urlFlagValues = [];
|
|
3519
3571
|
for (let i = 0; i < args.length; i++) {
|
|
3520
3572
|
const tok = args[i];
|
|
@@ -3534,21 +3586,21 @@ function destTokensForBinary(binary, args) {
|
|
|
3534
3586
|
if (valueFlags.has(tok)) i++;
|
|
3535
3587
|
continue;
|
|
3536
3588
|
}
|
|
3537
|
-
|
|
3589
|
+
positionals2.push(tok);
|
|
3538
3590
|
}
|
|
3539
3591
|
switch (binary) {
|
|
3540
3592
|
case "curl":
|
|
3541
3593
|
case "wget":
|
|
3542
|
-
return [...urlFlagValues, ...
|
|
3594
|
+
return [...urlFlagValues, ...positionals2];
|
|
3543
3595
|
case "ssh":
|
|
3544
|
-
return
|
|
3596
|
+
return positionals2.slice(0, 1);
|
|
3545
3597
|
case "scp":
|
|
3546
3598
|
case "rsync":
|
|
3547
|
-
return
|
|
3599
|
+
return positionals2.filter((p) => p.includes(":") || p.includes("@"));
|
|
3548
3600
|
case "nc":
|
|
3549
3601
|
case "ncat":
|
|
3550
3602
|
case "netcat":
|
|
3551
|
-
return
|
|
3603
|
+
return positionals2.slice(0, 1);
|
|
3552
3604
|
default:
|
|
3553
3605
|
return [];
|
|
3554
3606
|
}
|
|
@@ -3565,16 +3617,18 @@ function extractShellDestinations(command) {
|
|
|
3565
3617
|
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
3566
3618
|
const callArgs = n.Args || [];
|
|
3567
3619
|
if (callArgs.length === 0) return true;
|
|
3568
|
-
const
|
|
3620
|
+
const words = callArgs.map((a) => resolveWordLiteral(a));
|
|
3621
|
+
const at = unwrapCommandHead(words);
|
|
3622
|
+
const name = (words[at] || "").toLowerCase().split("/").pop() ?? "";
|
|
3569
3623
|
if (!NET_BINARIES.has(name)) return true;
|
|
3570
|
-
const rest =
|
|
3624
|
+
const rest = words.slice(at + 1);
|
|
3571
3625
|
for (const raw of destTokensForBinary(name, rest)) {
|
|
3572
|
-
const
|
|
3573
|
-
if (!
|
|
3574
|
-
const key = `${name}:${
|
|
3626
|
+
const host2 = parseDestHost(raw);
|
|
3627
|
+
if (!host2) continue;
|
|
3628
|
+
const key = `${name}:${host2}`;
|
|
3575
3629
|
if (seen.has(key)) continue;
|
|
3576
3630
|
seen.add(key);
|
|
3577
|
-
out.push({ host, binary: name, raw });
|
|
3631
|
+
out.push({ host: host2, binary: name, raw });
|
|
3578
3632
|
}
|
|
3579
3633
|
return true;
|
|
3580
3634
|
});
|
|
@@ -4466,36 +4520,129 @@ var BASH_TOOL_NAMES = /* @__PURE__ */ new Set([
|
|
|
4466
4520
|
"shell",
|
|
4467
4521
|
"exec_command"
|
|
4468
4522
|
]);
|
|
4469
|
-
var MCP_EXECUTORS = /* @__PURE__ */ new Set([
|
|
4523
|
+
var MCP_EXECUTORS = /* @__PURE__ */ new Set([
|
|
4524
|
+
...BASH_TOOL_NAMES,
|
|
4525
|
+
"exec",
|
|
4526
|
+
"run_command",
|
|
4527
|
+
"terminal",
|
|
4528
|
+
"execute_command",
|
|
4529
|
+
"execute_shell",
|
|
4530
|
+
"execute_shell_command",
|
|
4531
|
+
"shell_execute",
|
|
4532
|
+
"run_shell",
|
|
4533
|
+
"run_terminal_command",
|
|
4534
|
+
"start_process"
|
|
4535
|
+
]);
|
|
4536
|
+
var BUILTIN_FIELDS = ["command", "cmd", "script"];
|
|
4537
|
+
var ARGV_FIELDS = ["args", "argv"];
|
|
4538
|
+
var BARE_WORD = /^[A-Za-z0-9_./+:@%,-]+$/;
|
|
4539
|
+
var MAX_ARGV_CHARACTERS = 262144;
|
|
4470
4540
|
function isBashTool(tool) {
|
|
4471
4541
|
return BASH_TOOL_NAMES.has(tool.toLowerCase());
|
|
4472
4542
|
}
|
|
4473
|
-
function
|
|
4543
|
+
function inspectionLayers(policy) {
|
|
4544
|
+
return { trusted: policy.toolInspection, project: policy.projectToolInspection };
|
|
4545
|
+
}
|
|
4546
|
+
function isShellEntry(value) {
|
|
4547
|
+
return typeof value === "object" && value !== null && value.kind === "shell" && typeof value.field === "string" && Object.keys(value).length === 2;
|
|
4548
|
+
}
|
|
4549
|
+
function isInspectionLayers(input) {
|
|
4550
|
+
const trusted = input.trusted;
|
|
4551
|
+
return typeof trusted === "object" && trusted !== null && !isShellEntry(trusted);
|
|
4552
|
+
}
|
|
4553
|
+
function layersOf(input) {
|
|
4554
|
+
return isInspectionLayers(input) ? { trusted: input.trusted, project: input.project ?? {} } : { trusted: input, project: {} };
|
|
4555
|
+
}
|
|
4556
|
+
function entryOf(tool, inspection) {
|
|
4474
4557
|
const pattern = Object.keys(inspection).find((p) => matchesPattern(tool, p));
|
|
4475
4558
|
return pattern === void 0 ? void 0 : inspection[pattern];
|
|
4476
4559
|
}
|
|
4560
|
+
function inspectionEntry(tool, inspection = {}) {
|
|
4561
|
+
const { trusted, project } = layersOf(inspection);
|
|
4562
|
+
return entryOf(tool, trusted) ?? entryOf(tool, project);
|
|
4563
|
+
}
|
|
4564
|
+
function executorName(tool) {
|
|
4565
|
+
const name = tool.toLowerCase();
|
|
4566
|
+
if (!name.startsWith("mcp__")) return name;
|
|
4567
|
+
const at = name.lastIndexOf("__");
|
|
4568
|
+
return at >= "mcp__".length ? name.slice(at + 2) : name;
|
|
4569
|
+
}
|
|
4570
|
+
function entryFields(entry) {
|
|
4571
|
+
if (typeof entry === "object") return [entry.field];
|
|
4572
|
+
return entry === "command" ? ["command"] : null;
|
|
4573
|
+
}
|
|
4477
4574
|
function shellFields(tool, inspection) {
|
|
4478
4575
|
if (isBashTool(tool)) return ["command"];
|
|
4479
|
-
const
|
|
4480
|
-
|
|
4481
|
-
if (
|
|
4482
|
-
const
|
|
4483
|
-
|
|
4576
|
+
const { trusted, project } = layersOf(inspection);
|
|
4577
|
+
const trustedEntry = entryOf(tool, trusted);
|
|
4578
|
+
if (trustedEntry !== void 0) return entryFields(trustedEntry);
|
|
4579
|
+
const builtin = MCP_EXECUTORS.has(executorName(tool)) ? BUILTIN_FIELDS : null;
|
|
4580
|
+
const projectEntry = entryOf(tool, project);
|
|
4581
|
+
if (projectEntry === void 0) return builtin;
|
|
4582
|
+
const added = entryFields(projectEntry);
|
|
4583
|
+
if (!builtin) return added;
|
|
4584
|
+
if (!added) return builtin;
|
|
4585
|
+
return [.../* @__PURE__ */ new Set([...builtin, ...added])];
|
|
4484
4586
|
}
|
|
4485
4587
|
function isShellShapedTool(tool, inspection = {}) {
|
|
4486
4588
|
return shellFields(tool, inspection) !== null;
|
|
4487
4589
|
}
|
|
4590
|
+
function shellWord(word) {
|
|
4591
|
+
if (BARE_WORD.test(word)) return word;
|
|
4592
|
+
return word === "" ? "''" : `'${word.replace(/'/g, `'\\''`)}'`;
|
|
4593
|
+
}
|
|
4594
|
+
function isStringArray(value) {
|
|
4595
|
+
return Array.isArray(value) && value.every((item) => typeof item === "string");
|
|
4596
|
+
}
|
|
4597
|
+
function commandLine(args, fieldPath, value, native) {
|
|
4598
|
+
const missing = { reason: "Shell command field is missing or is not a string" };
|
|
4599
|
+
const unreadable = { reason: "Shell command arguments could not be read" };
|
|
4600
|
+
if (typeof value !== "string" && (native || !Array.isArray(value))) return missing;
|
|
4601
|
+
const dot = fieldPath.lastIndexOf(".");
|
|
4602
|
+
const parent = dot === -1 ? args : getNestedValue(args, fieldPath.slice(0, dot));
|
|
4603
|
+
const siblings = ARGV_FIELDS.map((key) => ({
|
|
4604
|
+
key,
|
|
4605
|
+
value: parent && typeof parent === "object" ? parent[key] : void 0
|
|
4606
|
+
})).filter(({ value: value2 }) => value2 !== void 0 && value2 !== null);
|
|
4607
|
+
let argv = siblings[0];
|
|
4608
|
+
if (native) argv = siblings.find(({ value: v }) => isStringArray(v));
|
|
4609
|
+
else if (siblings.length === 2 && JSON.stringify(siblings[0].value) !== JSON.stringify(siblings[1].value))
|
|
4610
|
+
return { reason: "Shell command arguments disagree" };
|
|
4611
|
+
let command;
|
|
4612
|
+
let source = fieldPath;
|
|
4613
|
+
if (Array.isArray(value)) {
|
|
4614
|
+
if (argv || !value.length || !isStringArray(value)) return unreadable;
|
|
4615
|
+
command = value.map(shellWord).join(" ");
|
|
4616
|
+
} else if (!argv) {
|
|
4617
|
+
return { command: value, fieldPath };
|
|
4618
|
+
} else {
|
|
4619
|
+
if (!isStringArray(argv.value)) return unreadable;
|
|
4620
|
+
if (!argv.value.length) return { command: value, fieldPath };
|
|
4621
|
+
command = `${value} ${argv.value.map(shellWord).join(" ")}`;
|
|
4622
|
+
source = `${fieldPath}+${argv.key}`;
|
|
4623
|
+
}
|
|
4624
|
+
if (command.length > MAX_ARGV_CHARACTERS)
|
|
4625
|
+
return { reason: "Shell command arguments exceed the inspectable size" };
|
|
4626
|
+
return { command, fieldPath: source };
|
|
4627
|
+
}
|
|
4488
4628
|
function resolveShellInput(tool, args, inspection = {}) {
|
|
4489
4629
|
const fields = shellFields(tool, inspection);
|
|
4490
4630
|
if (!fields) return { kind: "not-shell" };
|
|
4491
4631
|
const values = fields.map((fieldPath) => ({ fieldPath, value: getNestedValue(args, fieldPath) })).filter(({ value }) => value !== void 0 && value !== null && value !== "");
|
|
4492
|
-
if (!values.length
|
|
4632
|
+
if (!values.length) {
|
|
4493
4633
|
return { kind: "uninspectable", reason: "Shell command field is missing or is not a string" };
|
|
4494
4634
|
}
|
|
4495
|
-
|
|
4635
|
+
const native = isBashTool(tool);
|
|
4636
|
+
const lines = values.map(({ fieldPath, value }) => commandLine(args, fieldPath, value, native));
|
|
4637
|
+
const failed = lines.find((line) => "reason" in line);
|
|
4638
|
+
if (failed) return { kind: "uninspectable", reason: failed.reason };
|
|
4639
|
+
const commands = lines.filter(
|
|
4640
|
+
(line) => "command" in line
|
|
4641
|
+
);
|
|
4642
|
+
if (new Set(commands.map(({ command }) => command)).size !== 1) {
|
|
4496
4643
|
return { kind: "uninspectable", reason: "Multiple shell command fields disagree" };
|
|
4497
4644
|
}
|
|
4498
|
-
return { kind: "shell",
|
|
4645
|
+
return { kind: "shell", ...commands[0] };
|
|
4499
4646
|
}
|
|
4500
4647
|
function shellRuleArgs(tool, args, ruleTool, inspection = {}) {
|
|
4501
4648
|
if (!ruleTool || !matchesPattern("bash", ruleTool) || matchesPattern(tool, ruleTool)) return args;
|
|
@@ -5108,6 +5255,33 @@ var SYSTEM_AUTH_FILES = [
|
|
|
5108
5255
|
var SYSTEM_AUTH_DIRS = ["/etc/security", "/etc/pam.d", "/etc/sudoers.d"];
|
|
5109
5256
|
var PASSWORD_HASH_FILES = ["/etc/shadow", "/etc/gshadow"];
|
|
5110
5257
|
var STARTUP_NAMES = [".bashrc", ".zshrc", ".profile", ".bash_profile"];
|
|
5258
|
+
var AGENT_INSTRUCTION_FILES = [
|
|
5259
|
+
".gitlab-ci.yml",
|
|
5260
|
+
"CLAUDE.md",
|
|
5261
|
+
"AGENTS.md",
|
|
5262
|
+
".cursorrules",
|
|
5263
|
+
".mcp.json",
|
|
5264
|
+
".vscode/settings.json",
|
|
5265
|
+
"package.json"
|
|
5266
|
+
];
|
|
5267
|
+
var AGENT_INSTRUCTION_DIRS = [
|
|
5268
|
+
".github/workflows",
|
|
5269
|
+
".claude",
|
|
5270
|
+
".cursor",
|
|
5271
|
+
".git/hooks",
|
|
5272
|
+
".husky"
|
|
5273
|
+
];
|
|
5274
|
+
function isAgentInstructionPath(absPath, root) {
|
|
5275
|
+
const r = root.replace(/\/$/, "");
|
|
5276
|
+
if (!(absPath === r || absPath.startsWith(r + "/"))) return false;
|
|
5277
|
+
const rel = absPath.slice(r.length + 1);
|
|
5278
|
+
if (AGENT_INSTRUCTION_FILES.includes(rel)) return true;
|
|
5279
|
+
return AGENT_INSTRUCTION_DIRS.some((d) => rel === d || rel.startsWith(d + "/"));
|
|
5280
|
+
}
|
|
5281
|
+
function isInside(root, p) {
|
|
5282
|
+
const r = root.replace(/\/$/, "") || "/";
|
|
5283
|
+
return p === r || p.startsWith(r === "/" ? "/" : r + "/");
|
|
5284
|
+
}
|
|
5111
5285
|
var LEGACY_SYSTEM_PATH_RE = /^(?:[a-zA-Z]:)?\/etc\/(?:passwd|shadow|sudoers)$/;
|
|
5112
5286
|
function isPasswordHashPath(p) {
|
|
5113
5287
|
return PASSWORD_HASH_FILES.includes(p);
|
|
@@ -7353,20 +7527,26 @@ var BIP39_PUBLIC_VECTORS = /* @__PURE__ */ new Set([
|
|
|
7353
7527
|
var indices = new Map(BIP39_ENGLISH.map((word, i) => [word, i]));
|
|
7354
7528
|
var lengths = [24, 21, 18, 15, 12];
|
|
7355
7529
|
var hash = (value) => createHash("sha256").update(value).digest();
|
|
7356
|
-
|
|
7357
|
-
|
|
7530
|
+
var MAX_MNEMONIC_HASHES = 25e3;
|
|
7531
|
+
function findMnemonic(text, budget = { hashes: 0, reasons: /* @__PURE__ */ new Set() }) {
|
|
7358
7532
|
let run = [];
|
|
7533
|
+
let runIndex = [];
|
|
7359
7534
|
let previousEnd = 0;
|
|
7360
7535
|
const rejected = /* @__PURE__ */ new Set();
|
|
7361
7536
|
const inspect = () => {
|
|
7537
|
+
if (run.length < 12) return false;
|
|
7538
|
+
const ascending = new Array(run.length).fill(0);
|
|
7539
|
+
for (let i = 1; i < run.length; i++)
|
|
7540
|
+
ascending[i] = ascending[i - 1] + (runIndex[i] > runIndex[i - 1] ? 1 : 0);
|
|
7362
7541
|
for (let start = 0; start + 12 <= run.length; start++) {
|
|
7363
7542
|
for (const count of lengths) {
|
|
7364
7543
|
if (start + count > run.length) continue;
|
|
7544
|
+
if (ascending[start + count - 1] - ascending[start] === count - 1) continue;
|
|
7365
7545
|
const candidate = run.slice(start, start + count);
|
|
7366
7546
|
const sentence = candidate.join(" ");
|
|
7367
7547
|
if (rejected.has(sentence)) continue;
|
|
7368
|
-
if (++budget.
|
|
7369
|
-
budget.reasons.add("mnemonic-
|
|
7548
|
+
if (++budget.hashes > MAX_MNEMONIC_HASHES) {
|
|
7549
|
+
budget.reasons.add("mnemonic-budget");
|
|
7370
7550
|
return false;
|
|
7371
7551
|
}
|
|
7372
7552
|
if (BIP39_PUBLIC_VECTORS.has(hash(sentence).toString("hex"))) {
|
|
@@ -7384,13 +7564,18 @@ function findMnemonic(text, budget = { candidates: 0, reasons: /* @__PURE__ */ n
|
|
|
7384
7564
|
}
|
|
7385
7565
|
return false;
|
|
7386
7566
|
};
|
|
7387
|
-
for (const word of
|
|
7388
|
-
|
|
7567
|
+
for (const word of text.matchAll(/[a-zA-Z]+/g)) {
|
|
7568
|
+
const index = indices.get(word[0]);
|
|
7569
|
+
if (index === void 0 || run.length && !/^\s+$/.test(text.slice(previousEnd, word.index))) {
|
|
7389
7570
|
if (inspect()) return true;
|
|
7390
|
-
if (budget.reasons.has("mnemonic-
|
|
7571
|
+
if (budget.reasons.has("mnemonic-budget")) return false;
|
|
7391
7572
|
run = [];
|
|
7573
|
+
runIndex = [];
|
|
7574
|
+
}
|
|
7575
|
+
if (index !== void 0) {
|
|
7576
|
+
run.push(word[0]);
|
|
7577
|
+
runIndex.push(index);
|
|
7392
7578
|
}
|
|
7393
|
-
if (indices.has(word[0])) run.push(word[0]);
|
|
7394
7579
|
previousEnd = word.index + word[0].length;
|
|
7395
7580
|
}
|
|
7396
7581
|
return inspect();
|
|
@@ -7633,6 +7818,10 @@ function validateCask(raw) {
|
|
|
7633
7818
|
|
|
7634
7819
|
// src/dlp/normalize.ts
|
|
7635
7820
|
var INVISIBLE_RE = /[͏----︀-️]|[\u{E0000}-\u{E007F}]/gu;
|
|
7821
|
+
function isInvisibleChar(char) {
|
|
7822
|
+
return INVISIBLE_ONE.test(char);
|
|
7823
|
+
}
|
|
7824
|
+
var INVISIBLE_ONE = new RegExp(`^(?:${INVISIBLE_RE.source.split("|")[0]})$`, "u");
|
|
7636
7825
|
function stripInvisible(text) {
|
|
7637
7826
|
return text.replace(INVISIBLE_RE, "");
|
|
7638
7827
|
}
|
|
@@ -7808,7 +7997,7 @@ function scanInjection(text, ctx = {}) {
|
|
|
7808
7997
|
}
|
|
7809
7998
|
}
|
|
7810
7999
|
if (matched.length === 0) return null;
|
|
7811
|
-
const untrusted = !!ctx.tool && UNTRUSTED_TOOLS.test(ctx.tool);
|
|
8000
|
+
const untrusted = ctx.untrusted ?? (!!ctx.tool && UNTRUSTED_TOOLS.test(ctx.tool));
|
|
7812
8001
|
const score = matched.length + (untrusted ? 1 : 0);
|
|
7813
8002
|
const confidence = score >= 3 ? "high" : score === 2 ? "medium" : "low";
|
|
7814
8003
|
return { signals: untrusted ? [...matched, "untrusted-origin"] : matched, confidence };
|
|
@@ -8596,6 +8785,46 @@ function matchArgumentText(text, fieldPath, budget) {
|
|
|
8596
8785
|
}
|
|
8597
8786
|
return best;
|
|
8598
8787
|
}
|
|
8788
|
+
var BATCH_SEPARATOR = "\n";
|
|
8789
|
+
function matchArgumentBatch(fragments, fieldPath, budget) {
|
|
8790
|
+
if (!fragments.length) return null;
|
|
8791
|
+
const text = fragments.join(BATCH_SEPARATOR);
|
|
8792
|
+
const lower2 = text.toLowerCase();
|
|
8793
|
+
let best = null;
|
|
8794
|
+
for (const pattern of DLP_PATTERNS) {
|
|
8795
|
+
if (pattern.keywords && !pattern.keywords.some((kw) => lower2.includes(kw.toLowerCase())))
|
|
8796
|
+
continue;
|
|
8797
|
+
const flags = pattern.regex.flags.replace(/[gmy]/g, "");
|
|
8798
|
+
if (!new RegExp(pattern.regex.source, flags + "m").test(text)) continue;
|
|
8799
|
+
for (const fragment of fragments) {
|
|
8800
|
+
if (firstAcceptedMatch(pattern, fragment) === null) continue;
|
|
8801
|
+
const severity = pattern.contextBoost && isAssignmentContext(fragment) ? "block" : pattern.severity;
|
|
8802
|
+
if (severity === "block")
|
|
8803
|
+
return {
|
|
8804
|
+
patternName: pattern.name,
|
|
8805
|
+
fieldPath,
|
|
8806
|
+
redactedSample: "[encoded secret]",
|
|
8807
|
+
severity
|
|
8808
|
+
};
|
|
8809
|
+
best ??= {
|
|
8810
|
+
patternName: pattern.name,
|
|
8811
|
+
fieldPath,
|
|
8812
|
+
redactedSample: "[encoded secret]",
|
|
8813
|
+
severity
|
|
8814
|
+
};
|
|
8815
|
+
if (!pattern.contextBoost) break;
|
|
8816
|
+
}
|
|
8817
|
+
}
|
|
8818
|
+
if (findMnemonic(text, budget)) {
|
|
8819
|
+
return {
|
|
8820
|
+
patternName: "BIP-39 Recovery Phrase",
|
|
8821
|
+
fieldPath,
|
|
8822
|
+
redactedSample: "[recovery phrase]",
|
|
8823
|
+
severity: "block"
|
|
8824
|
+
};
|
|
8825
|
+
}
|
|
8826
|
+
return best;
|
|
8827
|
+
}
|
|
8599
8828
|
function scanArgs(args, depth = 0, fieldPath = "args") {
|
|
8600
8829
|
if (depth > MAX_DEPTH2 || args === null || args === void 0) return null;
|
|
8601
8830
|
if (Array.isArray(args)) {
|
|
@@ -9322,7 +9551,25 @@ var TUNING_FIELDS = [
|
|
|
9322
9551
|
name: "onlineFallback",
|
|
9323
9552
|
legacy: ["packageCheck", "onlineFallback"]
|
|
9324
9553
|
},
|
|
9325
|
-
{ checkId: "loading.malicious-package", name: "allow", legacy: ["packageCheck", "allow"] }
|
|
9554
|
+
{ checkId: "loading.malicious-package", name: "allow", legacy: ["packageCheck", "allow"] },
|
|
9555
|
+
// fw#318: the verdict carries off / log (log-only) / review; the tuning
|
|
9556
|
+
// carries whether a review asks once per destination or every time, the
|
|
9557
|
+
// frame around outside content, and the organisation's own domains.
|
|
9558
|
+
{
|
|
9559
|
+
checkId: "behavior.untrusted-content",
|
|
9560
|
+
name: "afterExposure",
|
|
9561
|
+
legacy: ["untrustedContent", "afterExposure"]
|
|
9562
|
+
},
|
|
9563
|
+
{
|
|
9564
|
+
checkId: "behavior.untrusted-content",
|
|
9565
|
+
name: "spotlight",
|
|
9566
|
+
legacy: ["untrustedContent", "spotlight"]
|
|
9567
|
+
},
|
|
9568
|
+
{
|
|
9569
|
+
checkId: "behavior.untrusted-content",
|
|
9570
|
+
name: "orgDomains",
|
|
9571
|
+
legacy: ["untrustedContent", "orgDomains"]
|
|
9572
|
+
}
|
|
9326
9573
|
];
|
|
9327
9574
|
function tuningFromLegacyPolicy(policy) {
|
|
9328
9575
|
const out = {};
|
|
@@ -9401,6 +9648,10 @@ function checksFromLegacyPolicy(policy, mode) {
|
|
|
9401
9648
|
if (pkg?.enabled === false) out["loading.malicious-package"] = "off";
|
|
9402
9649
|
else if (pkg?.enabled === true)
|
|
9403
9650
|
out["loading.malicious-package"] = pkg.onMalicious === "review" ? "review" : "block";
|
|
9651
|
+
const uc = policy.untrustedContent;
|
|
9652
|
+
if (uc?.enabled === false) out["behavior.untrusted-content"] = "off";
|
|
9653
|
+
else if (uc?.enabled === true)
|
|
9654
|
+
out["behavior.untrusted-content"] = uc.afterExposure === "log-only" ? "log" : "review";
|
|
9404
9655
|
if (mode === "strict") out["commands.unknown"] = "review";
|
|
9405
9656
|
return out;
|
|
9406
9657
|
}
|
|
@@ -9482,6 +9733,13 @@ function checkToLegacyPolicy(policy, id, v) {
|
|
|
9482
9733
|
return offOr("packageCheck", () => {
|
|
9483
9734
|
obj("packageCheck").onMalicious = v === "review" ? "review" : "block";
|
|
9484
9735
|
});
|
|
9736
|
+
case "behavior.untrusted-content":
|
|
9737
|
+
if (v !== "off" && v !== "log" && v !== "review") return false;
|
|
9738
|
+
return offOr("untrustedContent", () => {
|
|
9739
|
+
const uc = obj("untrustedContent");
|
|
9740
|
+
if (v === "log") uc.afterExposure = "log-only";
|
|
9741
|
+
else if (uc.afterExposure !== "ask-every-time") uc.afterExposure = "ask-once";
|
|
9742
|
+
});
|
|
9485
9743
|
default:
|
|
9486
9744
|
return false;
|
|
9487
9745
|
}
|
|
@@ -9501,6 +9759,7 @@ var MAP_GOVERNED = /* @__PURE__ */ new Set([
|
|
|
9501
9759
|
"commands.temp-binary",
|
|
9502
9760
|
"commands.disk-destroy",
|
|
9503
9761
|
"commands.dangerous-word",
|
|
9762
|
+
"commands.node9-disarm",
|
|
9504
9763
|
"data.pipe-chain"
|
|
9505
9764
|
]);
|
|
9506
9765
|
var KNOB_GOVERNED = {
|
|
@@ -9512,7 +9771,8 @@ var KNOB_GOVERNED = {
|
|
|
9512
9771
|
"behavior.loops": ["off", "block"],
|
|
9513
9772
|
"behavior.prompt-injection": ["off", "log"],
|
|
9514
9773
|
"loading.skill-tamper": ["off", "log", "block"],
|
|
9515
|
-
"loading.malicious-package": ["off", "review", "block"]
|
|
9774
|
+
"loading.malicious-package": ["off", "review", "block"],
|
|
9775
|
+
"behavior.untrusted-content": ["off", "log", "review"]
|
|
9516
9776
|
};
|
|
9517
9777
|
function isKnobGoverned(id) {
|
|
9518
9778
|
return id in KNOB_GOVERNED;
|
|
@@ -9551,39 +9811,39 @@ var DEFAULT_EGRESS_ALLOWLIST = [
|
|
|
9551
9811
|
"deb.debian.org",
|
|
9552
9812
|
"*.ubuntu.com"
|
|
9553
9813
|
];
|
|
9554
|
-
function hostMatches(
|
|
9814
|
+
function hostMatches(host2, pattern) {
|
|
9555
9815
|
const p = pattern.trim().toLowerCase();
|
|
9556
9816
|
if (!p) return false;
|
|
9557
9817
|
if (p === "*") return true;
|
|
9558
|
-
const h = canonicalHost(
|
|
9818
|
+
const h = canonicalHost(host2);
|
|
9559
9819
|
if (p.startsWith("*.")) {
|
|
9560
9820
|
const suffix = canonicalHost(p.slice(2));
|
|
9561
9821
|
return h === suffix || h.endsWith("." + suffix);
|
|
9562
9822
|
}
|
|
9563
9823
|
return h === canonicalHost(p);
|
|
9564
9824
|
}
|
|
9565
|
-
function matchesAny(
|
|
9566
|
-
for (const p of patterns ?? []) if (hostMatches(
|
|
9825
|
+
function matchesAny(host2, patterns) {
|
|
9826
|
+
for (const p of patterns ?? []) if (hostMatches(host2, p)) return true;
|
|
9567
9827
|
return false;
|
|
9568
9828
|
}
|
|
9569
9829
|
var PRIVATE_HOST_SUFFIXES = [".local", ".internal", ".localhost"];
|
|
9570
|
-
function isUniqueLocalV6(
|
|
9571
|
-
const ip = normalizeIpLiteral(
|
|
9830
|
+
function isUniqueLocalV6(host2) {
|
|
9831
|
+
const ip = normalizeIpLiteral(host2);
|
|
9572
9832
|
if (!ip || !ip.includes(":")) return false;
|
|
9573
9833
|
const g = expandIpv6(ip);
|
|
9574
9834
|
return g !== null && (g[0] & 65024) === 64512;
|
|
9575
9835
|
}
|
|
9576
|
-
function isPrivateHost(
|
|
9577
|
-
const h =
|
|
9836
|
+
function isPrivateHost(host2) {
|
|
9837
|
+
const h = host2.trim().toLowerCase().replace(/\.$/, "");
|
|
9578
9838
|
const m = classifySsrf(h);
|
|
9579
9839
|
if (m) return m.kind === "address" && (m.tier === "private" || m.tier === "unspecified");
|
|
9580
9840
|
if (h === "localhost") return true;
|
|
9581
9841
|
if (PRIVATE_HOST_SUFFIXES.some((s) => h.endsWith(s))) return true;
|
|
9582
9842
|
return isUniqueLocalV6(h);
|
|
9583
9843
|
}
|
|
9584
|
-
function canonicalHost(
|
|
9585
|
-
const ip = normalizeIpLiteral(
|
|
9586
|
-
return ip ??
|
|
9844
|
+
function canonicalHost(host2) {
|
|
9845
|
+
const ip = normalizeIpLiteral(host2);
|
|
9846
|
+
return ip ?? host2.trim().toLowerCase().replace(/\.$/, "");
|
|
9587
9847
|
}
|
|
9588
9848
|
function evaluateEgress(dests, policy) {
|
|
9589
9849
|
if (!policy.enabled) return null;
|
|
@@ -9991,8 +10251,8 @@ function extractToolDestinations(toolName, args) {
|
|
|
9991
10251
|
const out = [];
|
|
9992
10252
|
for (const path of paths) {
|
|
9993
10253
|
for (const value of valuesAt(args, path)) {
|
|
9994
|
-
const
|
|
9995
|
-
if (
|
|
10254
|
+
const host2 = hostOf(value);
|
|
10255
|
+
if (host2) out.push({ host: host2, binary: toolName, raw: value });
|
|
9996
10256
|
}
|
|
9997
10257
|
}
|
|
9998
10258
|
return out;
|
|
@@ -10006,13 +10266,13 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
10006
10266
|
if (!paths) return null;
|
|
10007
10267
|
for (const path of paths) {
|
|
10008
10268
|
for (const value of valuesAt(args, path)) {
|
|
10009
|
-
const
|
|
10010
|
-
if (!
|
|
10011
|
-
const m = classifySsrf(
|
|
10269
|
+
const host2 = hostOf(value);
|
|
10270
|
+
if (!host2) continue;
|
|
10271
|
+
const m = classifySsrf(host2);
|
|
10012
10272
|
if (!m) continue;
|
|
10013
10273
|
if (isStrictGatedTier(m.tier) && !opts.ssrfStrict) continue;
|
|
10014
10274
|
if (m.overridable && ssrfExemptMatches(opts.ssrfAllow, m.normalized)) continue;
|
|
10015
|
-
return { ...m, argPath: path, host, reason: ssrfReason(m,
|
|
10275
|
+
return { ...m, argPath: path, host: host2, reason: ssrfReason(m, host2) };
|
|
10016
10276
|
}
|
|
10017
10277
|
}
|
|
10018
10278
|
return null;
|
|
@@ -10023,12 +10283,23 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
10023
10283
|
|
|
10024
10284
|
// src/dlp/secret-views.ts
|
|
10025
10285
|
var SECRET_VIEW_LIMITS = {
|
|
10286
|
+
/** A decoded text that itself decodes is followed this many layers; a deeper layer is reviewed. */
|
|
10026
10287
|
maxDepth: 4,
|
|
10027
|
-
|
|
10028
|
-
|
|
10029
|
-
|
|
10030
|
-
|
|
10288
|
+
/** Nested views per parent view, and nested text per call; past either the call is reviewed. */
|
|
10289
|
+
maxNestedViewsPerLeaf: 64,
|
|
10290
|
+
maxNestedBytes: 1048576,
|
|
10291
|
+
/** Joined hostname-label text per call; past it the call is reviewed. */
|
|
10292
|
+
maxJoinedLabelBytes: 1048576,
|
|
10293
|
+
/** Decoded fragments are matched in batches of about this many characters. */
|
|
10294
|
+
batchCharacters: 65536,
|
|
10295
|
+
/** Only a valid DNS name has its labels joined. */
|
|
10296
|
+
maxHostLength: 253,
|
|
10297
|
+
maxLabelLength: 63,
|
|
10298
|
+
maxLabels: 127
|
|
10031
10299
|
};
|
|
10300
|
+
function newSecretViewBudget() {
|
|
10301
|
+
return { hashes: 0, nestedBytes: 0, joinedLabelBytes: 0, reasons: /* @__PURE__ */ new Set() };
|
|
10302
|
+
}
|
|
10032
10303
|
function textBytes(buf) {
|
|
10033
10304
|
if (buf.length < 16) return null;
|
|
10034
10305
|
const text = buf.toString("utf8");
|
|
@@ -10047,13 +10318,41 @@ function percentOnce(text) {
|
|
|
10047
10318
|
}
|
|
10048
10319
|
});
|
|
10049
10320
|
}
|
|
10321
|
+
function* wrappedBase64(text) {
|
|
10322
|
+
if (!text.includes("\n")) return;
|
|
10323
|
+
const word = /^[A-Za-z0-9+/_-]+={0,2}$/;
|
|
10324
|
+
let run = [];
|
|
10325
|
+
let width = 0;
|
|
10326
|
+
const flush = function* () {
|
|
10327
|
+
if (run.length >= 2) yield run.join("");
|
|
10328
|
+
run = [];
|
|
10329
|
+
width = 0;
|
|
10330
|
+
};
|
|
10331
|
+
for (const raw of text.split("\n")) {
|
|
10332
|
+
const line = raw.trim();
|
|
10333
|
+
const full = line.length >= 16 && word.test(line) && !line.includes("=");
|
|
10334
|
+
if (full && (!run.length || line.length === width)) {
|
|
10335
|
+
run.push(line);
|
|
10336
|
+
width = line.length;
|
|
10337
|
+
continue;
|
|
10338
|
+
}
|
|
10339
|
+
if (run.length && word.test(line) && line.length >= 2 && line.length <= width) {
|
|
10340
|
+
run.push(line);
|
|
10341
|
+
yield* flush();
|
|
10342
|
+
continue;
|
|
10343
|
+
}
|
|
10344
|
+
yield* flush();
|
|
10345
|
+
if (full) {
|
|
10346
|
+
run.push(line);
|
|
10347
|
+
width = line.length;
|
|
10348
|
+
}
|
|
10349
|
+
}
|
|
10350
|
+
yield* flush();
|
|
10351
|
+
}
|
|
10050
10352
|
function* encodedRegions(text, budget) {
|
|
10051
10353
|
yield [text, false];
|
|
10354
|
+
for (const block of wrappedBase64(text)) yield [block, false];
|
|
10052
10355
|
for (const match of text.matchAll(/(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,30}:\/\/[^\s<>"']+/gi)) {
|
|
10053
|
-
if (++budget.candidates > SECRET_VIEW_LIMITS.maxCandidates) {
|
|
10054
|
-
budget.reasons.add("decode-candidates");
|
|
10055
|
-
return;
|
|
10056
|
-
}
|
|
10057
10356
|
try {
|
|
10058
10357
|
new URL(match[0]);
|
|
10059
10358
|
} catch {
|
|
@@ -10063,16 +10362,18 @@ function* encodedRegions(text, budget) {
|
|
|
10063
10362
|
/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/i
|
|
10064
10363
|
);
|
|
10065
10364
|
if (!parts) continue;
|
|
10066
|
-
const
|
|
10365
|
+
const host2 = parts[1].slice(parts[1].lastIndexOf("@") + 1).replace(/:\d+$/, "");
|
|
10067
10366
|
const regions = [
|
|
10068
10367
|
parts[1],
|
|
10069
|
-
...
|
|
10368
|
+
...host2.split("."),
|
|
10070
10369
|
...parts[2].split("/"),
|
|
10071
10370
|
...(parts[3] ?? "").split("&"),
|
|
10072
10371
|
parts[4] ?? ""
|
|
10073
10372
|
];
|
|
10074
10373
|
for (const region of regions) if (region) yield [region, false];
|
|
10075
|
-
const labels =
|
|
10374
|
+
const labels = host2.split(".");
|
|
10375
|
+
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))
|
|
10376
|
+
continue;
|
|
10076
10377
|
for (let start = 0; start < labels.length; start++) {
|
|
10077
10378
|
let joined = labels[start];
|
|
10078
10379
|
for (let end = start + 1; end < Math.min(labels.length, start + 8); end++) {
|
|
@@ -10080,11 +10381,13 @@ function* encodedRegions(text, budget) {
|
|
|
10080
10381
|
if (!run.every((s) => /^[a-f0-9]{2,}$/i.test(s)) && !run.every((s) => /^[A-Z2-7]{4,}$/i.test(s)))
|
|
10081
10382
|
break;
|
|
10082
10383
|
joined += labels[end];
|
|
10083
|
-
if (
|
|
10084
|
-
|
|
10384
|
+
if (joined.length < 16) continue;
|
|
10385
|
+
budget.joinedLabelBytes += joined.length;
|
|
10386
|
+
if (budget.joinedLabelBytes > SECRET_VIEW_LIMITS.maxJoinedLabelBytes) {
|
|
10387
|
+
budget.reasons.add("decode-labels");
|
|
10085
10388
|
return;
|
|
10086
10389
|
}
|
|
10087
|
-
|
|
10390
|
+
yield [joined, true];
|
|
10088
10391
|
}
|
|
10089
10392
|
}
|
|
10090
10393
|
}
|
|
@@ -10121,10 +10424,6 @@ function* decodedCandidates(text, budget) {
|
|
|
10121
10424
|
if (joined) yield ["dns-labels", region];
|
|
10122
10425
|
for (const [kind, re] of families) {
|
|
10123
10426
|
for (const match of region.matchAll(re)) {
|
|
10124
|
-
if (++budget.candidates > SECRET_VIEW_LIMITS.maxCandidates) {
|
|
10125
|
-
budget.reasons.add("decode-candidates");
|
|
10126
|
-
return;
|
|
10127
|
-
}
|
|
10128
10427
|
const raw = match[0];
|
|
10129
10428
|
let buf;
|
|
10130
10429
|
if (kind === "base64") {
|
|
@@ -10147,37 +10446,47 @@ function* decodedCandidates(text, budget) {
|
|
|
10147
10446
|
}
|
|
10148
10447
|
}
|
|
10149
10448
|
}
|
|
10150
|
-
function
|
|
10449
|
+
function secretViews(text, budget) {
|
|
10151
10450
|
const seen = /* @__PURE__ */ new Set([text]);
|
|
10152
|
-
const
|
|
10153
|
-
|
|
10154
|
-
|
|
10155
|
-
|
|
10156
|
-
for (const
|
|
10157
|
-
|
|
10158
|
-
|
|
10159
|
-
|
|
10160
|
-
|
|
10161
|
-
|
|
10162
|
-
|
|
10163
|
-
|
|
10164
|
-
|
|
10165
|
-
|
|
10451
|
+
const out = [];
|
|
10452
|
+
let frontier = [{ text, transforms: [] }];
|
|
10453
|
+
for (let depth = 1; depth <= SECRET_VIEW_LIMITS.maxDepth; depth++) {
|
|
10454
|
+
const next = [];
|
|
10455
|
+
for (const parent of frontier) {
|
|
10456
|
+
let perLeaf = 0;
|
|
10457
|
+
for (const [kind, decoded] of decodedCandidates(parent.text, budget)) {
|
|
10458
|
+
if (seen.has(decoded)) continue;
|
|
10459
|
+
seen.add(decoded);
|
|
10460
|
+
const normalizing = kind === "invisibles" || kind === "percent";
|
|
10461
|
+
if (depth >= 2 && !normalizing) {
|
|
10462
|
+
budget.nestedBytes += Buffer.byteLength(decoded);
|
|
10463
|
+
if (++perLeaf > SECRET_VIEW_LIMITS.maxNestedViewsPerLeaf || budget.nestedBytes > SECRET_VIEW_LIMITS.maxNestedBytes) {
|
|
10464
|
+
budget.reasons.add("decode-nested");
|
|
10465
|
+
return out;
|
|
10466
|
+
}
|
|
10467
|
+
}
|
|
10468
|
+
const view = { text: decoded, transforms: [...parent.transforms, kind] };
|
|
10469
|
+
out.push(view);
|
|
10470
|
+
next.push(view);
|
|
10166
10471
|
}
|
|
10167
|
-
seen.add(decoded);
|
|
10168
|
-
budget.views++;
|
|
10169
|
-
budget.bytes += bytes;
|
|
10170
|
-
queue.push({ text: decoded, transforms: [...view.transforms, kind] });
|
|
10171
10472
|
}
|
|
10172
|
-
|
|
10473
|
+
frontier = next;
|
|
10474
|
+
if (!frontier.length) return out;
|
|
10173
10475
|
}
|
|
10476
|
+
for (const view of frontier) {
|
|
10477
|
+
if (!decodedCandidates(view.text, budget).next().done) {
|
|
10478
|
+
budget.reasons.add("decode-nested");
|
|
10479
|
+
break;
|
|
10480
|
+
}
|
|
10481
|
+
}
|
|
10482
|
+
return out;
|
|
10174
10483
|
}
|
|
10175
10484
|
|
|
10176
10485
|
// src/dlp/arguments.ts
|
|
10177
10486
|
var ARGUMENT_SCAN_LIMITS = {
|
|
10178
10487
|
maxDepth: 12,
|
|
10179
10488
|
maxNodes: 16384,
|
|
10180
|
-
/**
|
|
10489
|
+
/** Text is matched and decoded in windows of this size. */
|
|
10181
10490
|
maxStringCharacters: 1e5,
|
|
10182
10491
|
/** Windows overlap by this much so a token on a window edge is still seen whole. */
|
|
10183
10492
|
windowOverlap: 4096,
|
|
@@ -10187,17 +10496,46 @@ var ARGUMENT_SCAN_LIMITS = {
|
|
|
10187
10496
|
maxTailBytes: 4194304,
|
|
10188
10497
|
maxJsonCharacters: 1e4
|
|
10189
10498
|
};
|
|
10499
|
+
var RUN_CHAR = /[A-Za-z0-9+/=_%\\.-]/;
|
|
10500
|
+
var runChar = (value, index) => {
|
|
10501
|
+
const char = value[index] ?? "";
|
|
10502
|
+
return RUN_CHAR.test(char) || char !== "" && isInvisibleChar(char);
|
|
10503
|
+
};
|
|
10504
|
+
function batches(views) {
|
|
10505
|
+
const out = [];
|
|
10506
|
+
let current = [];
|
|
10507
|
+
let size = 0;
|
|
10508
|
+
for (const { text } of views) {
|
|
10509
|
+
if (current.length && size + text.length > SECRET_VIEW_LIMITS.batchCharacters) {
|
|
10510
|
+
out.push(current);
|
|
10511
|
+
current = [];
|
|
10512
|
+
size = 0;
|
|
10513
|
+
}
|
|
10514
|
+
current.push(text);
|
|
10515
|
+
size += text.length;
|
|
10516
|
+
}
|
|
10517
|
+
if (current.length) out.push(current);
|
|
10518
|
+
return out;
|
|
10519
|
+
}
|
|
10190
10520
|
function inspectArgumentSecrets(args) {
|
|
10191
|
-
const budget =
|
|
10521
|
+
const budget = newSecretViewBudget();
|
|
10192
10522
|
const ancestors = /* @__PURE__ */ new Set();
|
|
10193
10523
|
let nodes = 0;
|
|
10194
10524
|
let sourceBytes = 0;
|
|
10195
10525
|
let tailBytes = 0;
|
|
10196
10526
|
let best = null;
|
|
10527
|
+
const blocked = () => best?.severity === "block";
|
|
10197
10528
|
const accept = (match) => {
|
|
10198
10529
|
if (match && (!best || best.severity !== "block" && match.severity === "block")) best = match;
|
|
10199
10530
|
};
|
|
10531
|
+
const decodeSegment = (segment, fieldPath) => {
|
|
10532
|
+
for (const batch of batches(secretViews(segment, budget))) {
|
|
10533
|
+
accept(matchArgumentBatch(batch, fieldPath, budget));
|
|
10534
|
+
if (blocked()) return;
|
|
10535
|
+
}
|
|
10536
|
+
};
|
|
10200
10537
|
const visit = (value, depth, fieldPath) => {
|
|
10538
|
+
if (blocked()) return;
|
|
10201
10539
|
if (++nodes > ARGUMENT_SCAN_LIMITS.maxNodes) {
|
|
10202
10540
|
budget.reasons.add("argument-nodes");
|
|
10203
10541
|
return;
|
|
@@ -10239,14 +10577,11 @@ function inspectArgumentSecrets(args) {
|
|
|
10239
10577
|
}
|
|
10240
10578
|
sourceBytes += Math.min(bytes, Math.max(0, remaining));
|
|
10241
10579
|
if (!text) return;
|
|
10242
|
-
|
|
10243
|
-
|
|
10244
|
-
if (hit)
|
|
10245
|
-
accept(view.transforms.length ? { ...hit, redactedSample: "[encoded secret]" } : hit);
|
|
10246
|
-
}
|
|
10580
|
+
accept(matchArgumentText(text, fieldPath, budget));
|
|
10581
|
+
let scannedEnd = text.length;
|
|
10247
10582
|
if (!truncated && value.length > window) {
|
|
10248
|
-
budget.reasons.add("decode-window");
|
|
10249
10583
|
for (let start = window - overlap; start < value.length; start += window - overlap) {
|
|
10584
|
+
if (blocked()) return;
|
|
10250
10585
|
const chunk = value.slice(start, start + window);
|
|
10251
10586
|
const chunkBytes = Buffer.byteLength(chunk);
|
|
10252
10587
|
if (tailBytes + chunkBytes > ARGUMENT_SCAN_LIMITS.maxTailBytes) {
|
|
@@ -10255,9 +10590,16 @@ function inspectArgumentSecrets(args) {
|
|
|
10255
10590
|
}
|
|
10256
10591
|
tailBytes += chunkBytes;
|
|
10257
10592
|
accept(matchArgumentText(chunk, fieldPath, budget));
|
|
10593
|
+
scannedEnd = start + chunk.length;
|
|
10258
10594
|
if (start + window >= value.length) break;
|
|
10259
10595
|
}
|
|
10260
10596
|
}
|
|
10597
|
+
for (let start = 0; start < scannedEnd && !blocked(); ) {
|
|
10598
|
+
let end = Math.min(start + window, scannedEnd);
|
|
10599
|
+
while (end < scannedEnd && runChar(value, end - 1) && runChar(value, end)) end++;
|
|
10600
|
+
decodeSegment(value.slice(start, end), fieldPath);
|
|
10601
|
+
start = end;
|
|
10602
|
+
}
|
|
10261
10603
|
const trimmed = text.trim();
|
|
10262
10604
|
if (value.length < ARGUMENT_SCAN_LIMITS.maxJsonCharacters && (trimmed.startsWith("{") || trimmed.startsWith("["))) {
|
|
10263
10605
|
try {
|
|
@@ -10276,7 +10618,7 @@ function inspectArgumentSecrets(args) {
|
|
|
10276
10618
|
function scanArgumentSecrets(args) {
|
|
10277
10619
|
const result = inspectArgumentSecrets(args);
|
|
10278
10620
|
if (result.match) return result.match;
|
|
10279
|
-
return result.
|
|
10621
|
+
return result.coverage === "incomplete" ? {
|
|
10280
10622
|
patternName: "Argument inspection incomplete",
|
|
10281
10623
|
fieldPath: "args",
|
|
10282
10624
|
redactedSample: "[uninspected content]",
|
|
@@ -10311,18 +10653,13 @@ function tokenize2(toolName) {
|
|
|
10311
10653
|
return toolName.toLowerCase().split(/[_.\-\s]+/).filter(Boolean);
|
|
10312
10654
|
}
|
|
10313
10655
|
function extractShellCommand(toolName, args, toolInspection) {
|
|
10314
|
-
const
|
|
10315
|
-
|
|
10316
|
-
if (!matchingPattern) return null;
|
|
10317
|
-
const fieldPath = toolInspection[matchingPattern];
|
|
10656
|
+
const fieldPath = inspectionEntry(toolName, toolInspection);
|
|
10657
|
+
if (fieldPath === void 0) return null;
|
|
10318
10658
|
const value = getNestedValue(args, typeof fieldPath === "string" ? fieldPath : fieldPath.field);
|
|
10319
10659
|
return typeof value === "string" ? value : null;
|
|
10320
10660
|
}
|
|
10321
10661
|
function isSqlTool(toolName, toolInspection) {
|
|
10322
|
-
const
|
|
10323
|
-
const matchingPattern = patterns.find((p) => matchesPattern(toolName, p));
|
|
10324
|
-
if (!matchingPattern) return false;
|
|
10325
|
-
const fieldName = toolInspection[matchingPattern];
|
|
10662
|
+
const fieldName = inspectionEntry(toolName, toolInspection);
|
|
10326
10663
|
return fieldName === "sql" || fieldName === "query";
|
|
10327
10664
|
}
|
|
10328
10665
|
var SQL_DML_KEYWORDS = /* @__PURE__ */ new Set(["select", "insert", "update", "delete", "merge", "upsert"]);
|
|
@@ -10340,7 +10677,7 @@ function pipeChainVerdict(command, isTrustedHost, highAction = "review") {
|
|
|
10340
10677
|
if (!pipeAnalysis.isPipeline) return null;
|
|
10341
10678
|
if (pipeAnalysis.risk !== "critical" && pipeAnalysis.risk !== "high") return null;
|
|
10342
10679
|
const sinks = pipeAnalysis.sinkTargets;
|
|
10343
|
-
const allTrusted = sinks.length > 0 && sinks.every((
|
|
10680
|
+
const allTrusted = sinks.length > 0 && sinks.every((host2) => isTrustedHost ? isTrustedHost(host2) : false);
|
|
10344
10681
|
if (pipeAnalysis.risk === "critical") {
|
|
10345
10682
|
if (allTrusted) {
|
|
10346
10683
|
return {
|
|
@@ -10399,9 +10736,10 @@ function egressPolicyVerdict(eg) {
|
|
|
10399
10736
|
}
|
|
10400
10737
|
async function evaluatePolicy(config, toolName, args, context = {}, hooks = {}) {
|
|
10401
10738
|
let protectedVerdict = null;
|
|
10739
|
+
const layers = inspectionLayers(config.policy);
|
|
10402
10740
|
if (context.agent !== "Terminal") {
|
|
10403
10741
|
try {
|
|
10404
|
-
const accesses = context.accesses ?? collectFileAccesses(toolName, args, context,
|
|
10742
|
+
const accesses = context.accesses ?? collectFileAccesses(toolName, args, context, layers);
|
|
10405
10743
|
protectedVerdict = evaluateProtectedFileAccess(accesses, context, catalogSettings(config));
|
|
10406
10744
|
} catch {
|
|
10407
10745
|
protectedVerdict = incompleteFileVerdict();
|
|
@@ -10436,7 +10774,7 @@ async function evaluatePolicy(config, toolName, args, context = {}, hooks = {})
|
|
|
10436
10774
|
hooks
|
|
10437
10775
|
);
|
|
10438
10776
|
if (result.decision === "block") return result;
|
|
10439
|
-
if (context.agent !== "Terminal" && resolveShellInput(toolName, args,
|
|
10777
|
+
if (context.agent !== "Terminal" && resolveShellInput(toolName, args, layers).kind === "uninspectable") {
|
|
10440
10778
|
return {
|
|
10441
10779
|
decision: "review",
|
|
10442
10780
|
ruleName: "shell-inspection-incomplete",
|
|
@@ -10452,13 +10790,14 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10452
10790
|
const { agent, cwd, activeEnvironment } = context;
|
|
10453
10791
|
const { checkProvenance, isTrustedHost } = hooks;
|
|
10454
10792
|
const settingsView = catalogSettings(config);
|
|
10793
|
+
const layers = inspectionLayers(config.policy);
|
|
10455
10794
|
const cv = (id) => checkValue(settingsView, id);
|
|
10456
10795
|
let loggedFinding;
|
|
10457
10796
|
const noteLogged = (v) => {
|
|
10458
10797
|
if (v?.logged && !loggedFinding) loggedFinding = v;
|
|
10459
10798
|
};
|
|
10460
10799
|
const allowed = () => loggedFinding ?? { decision: "allow" };
|
|
10461
|
-
const shellInput = resolveShellInput(toolName, args,
|
|
10800
|
+
const shellInput = resolveShellInput(toolName, args, layers);
|
|
10462
10801
|
const wouldBeIgnored = matchesPattern(toolName, config.policy.ignoredTools);
|
|
10463
10802
|
{
|
|
10464
10803
|
const dest = ssrfDestinationFloor(toolName, args, {
|
|
@@ -10563,13 +10902,10 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10563
10902
|
return { id, value: cv(id) };
|
|
10564
10903
|
};
|
|
10565
10904
|
const matches = config.policy.smartRules.filter((rule) => {
|
|
10566
|
-
if (!toolMatchesRule(toolName, rule.tool,
|
|
10905
|
+
if (!toolMatchesRule(toolName, rule.tool, layers)) return false;
|
|
10567
10906
|
if (astSuppressed(rule)) return false;
|
|
10568
10907
|
if (rmCleanupWaiver && rule.name === "review-rm" && rule.verdict === "review") return false;
|
|
10569
|
-
if (!evaluateSmartConditions(
|
|
10570
|
-
shellRuleArgs(toolName, args, rule.tool, config.policy.toolInspection),
|
|
10571
|
-
rule
|
|
10572
|
-
))
|
|
10908
|
+
if (!evaluateSmartConditions(shellRuleArgs(toolName, args, rule.tool, layers), rule))
|
|
10573
10909
|
return false;
|
|
10574
10910
|
const check = ruleCheck(rule);
|
|
10575
10911
|
if (check?.value === "off") return false;
|
|
@@ -10616,7 +10952,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10616
10952
|
let allTokens = [];
|
|
10617
10953
|
let pathTokens = [];
|
|
10618
10954
|
if (pendingToolEgress) return pendingToolEgress;
|
|
10619
|
-
const shellCommand = shellInput.kind === "shell" ? shellInput.command : shellInput.kind === "not-shell" ? extractShellCommand(toolName, args,
|
|
10955
|
+
const shellCommand = shellInput.kind === "shell" ? shellInput.command : shellInput.kind === "not-shell" ? extractShellCommand(toolName, args, layers) : null;
|
|
10620
10956
|
if (shellCommand) {
|
|
10621
10957
|
const analyzed = analyzeShellCommand(shellCommand);
|
|
10622
10958
|
allTokens = analyzed.allTokens;
|
|
@@ -10693,7 +11029,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10693
11029
|
if (["ssh", "scp", "rsync"].includes(firstToken)) {
|
|
10694
11030
|
const rawTokens = shellCommand.trim().split(/\s+/);
|
|
10695
11031
|
const sshHosts = extractAllSshHosts(rawTokens.slice(1));
|
|
10696
|
-
allTokens.
|
|
11032
|
+
allTokens = allTokens.concat(sshHosts);
|
|
10697
11033
|
}
|
|
10698
11034
|
if (firstToken && firstToken.startsWith("/") && checkProvenance) {
|
|
10699
11035
|
const prov = checkProvenance(firstToken, cwd);
|
|
@@ -10722,7 +11058,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10722
11058
|
};
|
|
10723
11059
|
}
|
|
10724
11060
|
}
|
|
10725
|
-
if (isSqlTool(toolName,
|
|
11061
|
+
if (isSqlTool(toolName, layers)) {
|
|
10726
11062
|
allTokens = allTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
|
|
10727
11063
|
}
|
|
10728
11064
|
} else {
|
|
@@ -10730,7 +11066,7 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
10730
11066
|
if (args && typeof args === "object") {
|
|
10731
11067
|
const flattenedArgs = JSON.stringify(args).toLowerCase();
|
|
10732
11068
|
const extraTokens = flattenedArgs.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 1);
|
|
10733
|
-
allTokens.
|
|
11069
|
+
allTokens = allTokens.concat(extraTokens);
|
|
10734
11070
|
}
|
|
10735
11071
|
}
|
|
10736
11072
|
const isManual = agent === "Terminal";
|
|
@@ -10818,6 +11154,638 @@ function isIgnoredTool(toolName, config) {
|
|
|
10818
11154
|
return matchesPattern(toolName, config.policy.ignoredTools);
|
|
10819
11155
|
}
|
|
10820
11156
|
|
|
11157
|
+
// src/exposure/destinations.ts
|
|
11158
|
+
var MAX_DESTINATIONS = 200;
|
|
11159
|
+
var MAX_SCAN_CHARS = 1e5;
|
|
11160
|
+
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;
|
|
11161
|
+
var URL_RE = /\b(?:[a-z][a-z0-9+.-]*:\/\/|www\.)[^\s<>"'`){}]+/gi;
|
|
11162
|
+
var IBAN_RE = /\b[A-Z]{2}\d{2}(?:[ -]?[A-Z0-9]{4}){2,7}(?:[ -]?[A-Z0-9]{1,4})?\b/g;
|
|
11163
|
+
var RECIPIENT_KEYS = /* @__PURE__ */ new Set([
|
|
11164
|
+
"to",
|
|
11165
|
+
"cc",
|
|
11166
|
+
"bcc",
|
|
11167
|
+
"recipient",
|
|
11168
|
+
"recipients",
|
|
11169
|
+
"email",
|
|
11170
|
+
"participants",
|
|
11171
|
+
"attendees",
|
|
11172
|
+
"destination",
|
|
11173
|
+
"iban",
|
|
11174
|
+
"account",
|
|
11175
|
+
// Where a request goes, when the value is a bare host or a scheme-less URL.
|
|
11176
|
+
"url",
|
|
11177
|
+
"uri",
|
|
11178
|
+
"host",
|
|
11179
|
+
"hostname",
|
|
11180
|
+
"endpoint",
|
|
11181
|
+
"server",
|
|
11182
|
+
"domain",
|
|
11183
|
+
"address",
|
|
11184
|
+
"webhook",
|
|
11185
|
+
"webhook_url",
|
|
11186
|
+
"callback",
|
|
11187
|
+
"callback_url",
|
|
11188
|
+
"target"
|
|
11189
|
+
]);
|
|
11190
|
+
function normalizeHost(raw) {
|
|
11191
|
+
let h = raw.trim().toLowerCase();
|
|
11192
|
+
if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
|
|
11193
|
+
if (!h || h === "localhost") return null;
|
|
11194
|
+
if (/^[0-9a-f:]+$/.test(h) && h.includes(":")) return h;
|
|
11195
|
+
if (!h.includes(".") || !/^[\p{L}\p{N}.-]+$/u.test(h)) return null;
|
|
11196
|
+
return h;
|
|
11197
|
+
}
|
|
11198
|
+
function hostOfUrl(value) {
|
|
11199
|
+
const v = value.replace(/[.,;:!?)\]}>'"`]+$/, "");
|
|
11200
|
+
try {
|
|
11201
|
+
const u = new URL(v.toLowerCase().startsWith("www.") ? `http://${v}` : v);
|
|
11202
|
+
return normalizeHost(u.hostname);
|
|
11203
|
+
} catch {
|
|
11204
|
+
return null;
|
|
11205
|
+
}
|
|
11206
|
+
}
|
|
11207
|
+
function addIbans(text, out) {
|
|
11208
|
+
for (const m of text.toUpperCase().matchAll(IBAN_RE)) {
|
|
11209
|
+
const compact = m[0].replace(/[ -]/g, "");
|
|
11210
|
+
if (validateIban(compact)) out.add(`iban:${compact}`);
|
|
11211
|
+
else if (/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(compact)) out.add(`account:${compact}`);
|
|
11212
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11213
|
+
}
|
|
11214
|
+
}
|
|
11215
|
+
function addEmails(text, out) {
|
|
11216
|
+
for (const m of text.matchAll(EMAIL_RE)) {
|
|
11217
|
+
out.add(`email:${m[0].toLowerCase()}`);
|
|
11218
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11219
|
+
}
|
|
11220
|
+
}
|
|
11221
|
+
function addUrlHosts(text, out) {
|
|
11222
|
+
for (const m of text.matchAll(URL_RE)) {
|
|
11223
|
+
const h = hostOfUrl(m[0]);
|
|
11224
|
+
if (h) out.add(`host:${h}`);
|
|
11225
|
+
if (out.size >= MAX_DESTINATIONS) return;
|
|
11226
|
+
}
|
|
11227
|
+
}
|
|
11228
|
+
function extractContentDestinations(text) {
|
|
11229
|
+
const out = /* @__PURE__ */ new Set();
|
|
11230
|
+
try {
|
|
11231
|
+
const t = text.length > MAX_SCAN_CHARS ? text.slice(0, MAX_SCAN_CHARS) : text;
|
|
11232
|
+
if (t.includes("@")) addEmails(t, out);
|
|
11233
|
+
if (out.size < MAX_DESTINATIONS) addUrlHosts(t, out);
|
|
11234
|
+
if (out.size < MAX_DESTINATIONS) addIbans(t, out);
|
|
11235
|
+
} catch {
|
|
11236
|
+
}
|
|
11237
|
+
return [...out];
|
|
11238
|
+
}
|
|
11239
|
+
function extractArgDestinations(args) {
|
|
11240
|
+
const out = /* @__PURE__ */ new Set();
|
|
11241
|
+
try {
|
|
11242
|
+
walk(args, void 0, out, 0);
|
|
11243
|
+
} catch {
|
|
11244
|
+
}
|
|
11245
|
+
return [...out];
|
|
11246
|
+
}
|
|
11247
|
+
function walk(value, key, out, depth) {
|
|
11248
|
+
if (out.size >= MAX_DESTINATIONS || depth > 12) return;
|
|
11249
|
+
if (typeof value === "string") {
|
|
11250
|
+
const s = value.length > MAX_SCAN_CHARS ? value.slice(0, MAX_SCAN_CHARS) : value;
|
|
11251
|
+
if (s.includes("@")) addEmails(s, out);
|
|
11252
|
+
addUrlHosts(s, out);
|
|
11253
|
+
addIbans(s, out);
|
|
11254
|
+
if (key && RECIPIENT_KEYS.has(key.toLowerCase()) && !/[\s@]/.test(s)) {
|
|
11255
|
+
const h = normalizeHost(
|
|
11256
|
+
s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/^\/\//, "").split(/[/?#]/)[0].replace(/:\d+$/, "")
|
|
11257
|
+
);
|
|
11258
|
+
if (h && (h.includes(":") || /\.\p{L}{2,}$/u.test(h))) out.add(`host:${h}`);
|
|
11259
|
+
const acct = s.replace(/[ .-]/g, "").toUpperCase();
|
|
11260
|
+
if (/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(acct) && !validateIban(acct))
|
|
11261
|
+
out.add(`account:${acct}`);
|
|
11262
|
+
}
|
|
11263
|
+
return;
|
|
11264
|
+
}
|
|
11265
|
+
if (Array.isArray(value)) {
|
|
11266
|
+
for (const v of value) walk(v, key, out, depth + 1);
|
|
11267
|
+
return;
|
|
11268
|
+
}
|
|
11269
|
+
if (value && typeof value === "object") {
|
|
11270
|
+
for (const [k, v] of Object.entries(value))
|
|
11271
|
+
walk(v, k, out, depth + 1);
|
|
11272
|
+
}
|
|
11273
|
+
}
|
|
11274
|
+
function destinationDomain(dest) {
|
|
11275
|
+
if (!dest.startsWith("email:")) return null;
|
|
11276
|
+
const at = dest.lastIndexOf("@");
|
|
11277
|
+
return at > 0 ? dest.slice(at + 1) : null;
|
|
11278
|
+
}
|
|
11279
|
+
function destinationKind(dest) {
|
|
11280
|
+
const i = dest.indexOf(":");
|
|
11281
|
+
const k = i > 0 ? dest.slice(0, i) : "";
|
|
11282
|
+
return k === "email" || k === "host" || k === "iban" || k === "account" ? k : null;
|
|
11283
|
+
}
|
|
11284
|
+
function destinationValue(dest) {
|
|
11285
|
+
const i = dest.indexOf(":");
|
|
11286
|
+
return i > 0 ? dest.slice(i + 1) : dest;
|
|
11287
|
+
}
|
|
11288
|
+
function isLoopbackHost(host2) {
|
|
11289
|
+
let h = host2.trim().toLowerCase();
|
|
11290
|
+
if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
|
|
11291
|
+
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";
|
|
11292
|
+
}
|
|
11293
|
+
function gitRepoPath(url) {
|
|
11294
|
+
const u = url.trim();
|
|
11295
|
+
if (!u) return null;
|
|
11296
|
+
let host2;
|
|
11297
|
+
let p;
|
|
11298
|
+
if (/^[a-z][a-z0-9+.-]*:\/\//i.test(u)) {
|
|
11299
|
+
try {
|
|
11300
|
+
const parsed = new URL(u);
|
|
11301
|
+
host2 = parsed.hostname.toLowerCase();
|
|
11302
|
+
p = decodeURIComponent(parsed.pathname);
|
|
11303
|
+
} catch {
|
|
11304
|
+
return null;
|
|
11305
|
+
}
|
|
11306
|
+
} else {
|
|
11307
|
+
const scp = /^(?:[^@/\s]+@)?([A-Za-z0-9.-]+):(?!\/\/)(.+)$/.exec(u);
|
|
11308
|
+
if (!scp || !scp[1].includes(".")) return null;
|
|
11309
|
+
host2 = scp[1].toLowerCase();
|
|
11310
|
+
p = scp[2];
|
|
11311
|
+
}
|
|
11312
|
+
let start = 0;
|
|
11313
|
+
let end = p.length;
|
|
11314
|
+
while (start < end && p[start] === "/") start++;
|
|
11315
|
+
while (end > start && p[end - 1] === "/") end--;
|
|
11316
|
+
const tail = p.slice(start, end).replace(/\.git$/i, "").toLowerCase();
|
|
11317
|
+
if (!host2 || !tail.includes("/")) return null;
|
|
11318
|
+
return `${host2}/${tail}`;
|
|
11319
|
+
}
|
|
11320
|
+
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;
|
|
11321
|
+
function isDestructiveToolName(bareTool) {
|
|
11322
|
+
return DESTRUCTIVE_VERB_RE.test(bareTool);
|
|
11323
|
+
}
|
|
11324
|
+
|
|
11325
|
+
// src/exposure/shell.ts
|
|
11326
|
+
import mvdanSh4 from "mvdan-sh";
|
|
11327
|
+
var { syntax: syntax4 } = mvdanSh4;
|
|
11328
|
+
var EMPTY = {
|
|
11329
|
+
fetches: false,
|
|
11330
|
+
sends: false,
|
|
11331
|
+
destinations: [],
|
|
11332
|
+
gitRemotes: [],
|
|
11333
|
+
repos: [],
|
|
11334
|
+
unresolved: false,
|
|
11335
|
+
fetchDestinations: [],
|
|
11336
|
+
fetchKinds: []
|
|
11337
|
+
};
|
|
11338
|
+
var CURL_SEND_FLAGS = /* @__PURE__ */ new Set([
|
|
11339
|
+
"-d",
|
|
11340
|
+
"--data",
|
|
11341
|
+
"--data-ascii",
|
|
11342
|
+
"--data-binary",
|
|
11343
|
+
"--data-raw",
|
|
11344
|
+
"--data-urlencode",
|
|
11345
|
+
"-F",
|
|
11346
|
+
"--form",
|
|
11347
|
+
"--form-string",
|
|
11348
|
+
"-T",
|
|
11349
|
+
"--upload-file",
|
|
11350
|
+
"--json"
|
|
11351
|
+
]);
|
|
11352
|
+
var WGET_SEND_FLAGS = /* @__PURE__ */ new Set(["--post-data", "--post-file", "--body-data", "--body-file"]);
|
|
11353
|
+
var IWR_SEND_FLAGS = /* @__PURE__ */ new Set(["-body", "-infile"]);
|
|
11354
|
+
var WRITE_METHODS = /* @__PURE__ */ new Set(["post", "put", "patch", "delete"]);
|
|
11355
|
+
var GH_READ = /* @__PURE__ */ new Set(["view", "list", "diff", "checks", "status", "download", "clone"]);
|
|
11356
|
+
var GH_WRITE = /* @__PURE__ */ new Set([
|
|
11357
|
+
"create",
|
|
11358
|
+
"comment",
|
|
11359
|
+
"edit",
|
|
11360
|
+
"close",
|
|
11361
|
+
"reopen",
|
|
11362
|
+
"merge",
|
|
11363
|
+
"review",
|
|
11364
|
+
"upload",
|
|
11365
|
+
"delete",
|
|
11366
|
+
"transfer",
|
|
11367
|
+
"pin",
|
|
11368
|
+
"lock",
|
|
11369
|
+
"ready",
|
|
11370
|
+
"set",
|
|
11371
|
+
"sync",
|
|
11372
|
+
"fork"
|
|
11373
|
+
]);
|
|
11374
|
+
var GH_HOSTNAME_FLAGS = /* @__PURE__ */ new Set(["--hostname", "-h", "-R", "--repo"]);
|
|
11375
|
+
var GH_REPO_VALUE_FLAGS = /* @__PURE__ */ new Set([
|
|
11376
|
+
"--hostname",
|
|
11377
|
+
"-R",
|
|
11378
|
+
"--repo",
|
|
11379
|
+
"-d",
|
|
11380
|
+
"--description",
|
|
11381
|
+
"-h",
|
|
11382
|
+
"--homepage",
|
|
11383
|
+
"--visibility",
|
|
11384
|
+
"--default-branch",
|
|
11385
|
+
"--add-topic",
|
|
11386
|
+
"--remove-topic",
|
|
11387
|
+
"-p",
|
|
11388
|
+
"--template",
|
|
11389
|
+
"-s",
|
|
11390
|
+
"--source",
|
|
11391
|
+
"-b",
|
|
11392
|
+
"--branch",
|
|
11393
|
+
"-l",
|
|
11394
|
+
"--license",
|
|
11395
|
+
"-g",
|
|
11396
|
+
"--gitignore",
|
|
11397
|
+
"-t",
|
|
11398
|
+
"--team",
|
|
11399
|
+
"-r",
|
|
11400
|
+
"--remote",
|
|
11401
|
+
"--org"
|
|
11402
|
+
]);
|
|
11403
|
+
var GH_API_VALUE_FLAGS = /* @__PURE__ */ new Set([
|
|
11404
|
+
"--hostname",
|
|
11405
|
+
"-X",
|
|
11406
|
+
"--method",
|
|
11407
|
+
"-f",
|
|
11408
|
+
"--raw-field",
|
|
11409
|
+
"-F",
|
|
11410
|
+
"--field",
|
|
11411
|
+
"-H",
|
|
11412
|
+
"--header",
|
|
11413
|
+
"--input",
|
|
11414
|
+
"-q",
|
|
11415
|
+
"--jq",
|
|
11416
|
+
"-t",
|
|
11417
|
+
"--template",
|
|
11418
|
+
"--cache",
|
|
11419
|
+
"-p",
|
|
11420
|
+
"--preview"
|
|
11421
|
+
]);
|
|
11422
|
+
var GIT_FETCH = /* @__PURE__ */ new Set(["clone", "fetch", "pull", "ls-remote"]);
|
|
11423
|
+
var PUBLISH = {
|
|
11424
|
+
npm: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "registry.npmjs.org", flag: ["--registry"] },
|
|
11425
|
+
pnpm: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "registry.npmjs.org", flag: ["--registry"] },
|
|
11426
|
+
yarn: {
|
|
11427
|
+
verbs: /* @__PURE__ */ new Set(["publish", "npm"]),
|
|
11428
|
+
registry: "registry.npmjs.org",
|
|
11429
|
+
flag: ["--registry"]
|
|
11430
|
+
},
|
|
11431
|
+
twine: { verbs: /* @__PURE__ */ new Set(["upload"]), registry: "upload.pypi.org", flag: ["--repository-url"] },
|
|
11432
|
+
cargo: { verbs: /* @__PURE__ */ new Set(["publish"]), registry: "crates.io", flag: ["--registry", "--index"] },
|
|
11433
|
+
gem: { verbs: /* @__PURE__ */ new Set(["push"]), registry: "rubygems.org", flag: ["--host"] },
|
|
11434
|
+
docker: { verbs: /* @__PURE__ */ new Set(["push"]), registry: "docker.io" }
|
|
11435
|
+
};
|
|
11436
|
+
var SHELLS2 = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
|
|
11437
|
+
var OWN_HEADS = /* @__PURE__ */ new Set([...Object.keys(PUBLISH), "git", "gh"]);
|
|
11438
|
+
var MAX_DEPTH3 = 3;
|
|
11439
|
+
function host(token) {
|
|
11440
|
+
if (!token) return null;
|
|
11441
|
+
const h = parseDestHost(token);
|
|
11442
|
+
return h ? `host:${h}` : null;
|
|
11443
|
+
}
|
|
11444
|
+
var CWD_CHANGERS = /* @__PURE__ */ new Set(["cd", "pushd", "popd"]);
|
|
11445
|
+
function ghRepoArg(v, defaultHost) {
|
|
11446
|
+
if (/:\/\/|@/.test(v)) {
|
|
11447
|
+
const r = gitRepoPath(v);
|
|
11448
|
+
if (r) return { host: r.split("/")[0], repo: r };
|
|
11449
|
+
}
|
|
11450
|
+
const parts = v.toLowerCase().replace(/\.git$/, "").split("/").filter(Boolean);
|
|
11451
|
+
if (parts.length === 3) return { host: parts[0], repo: parts.join("/") };
|
|
11452
|
+
if (parts.length === 2) return { host: defaultHost, repo: `${defaultHost}/${parts.join("/")}` };
|
|
11453
|
+
return { host: defaultHost, repo: `${defaultHost}/*` };
|
|
11454
|
+
}
|
|
11455
|
+
function ghApiRepo(endpoint, ghHost) {
|
|
11456
|
+
if (endpoint === null) return `${ghHost}/*`;
|
|
11457
|
+
const e = endpoint.replace(/^https?:\/\/[^/]+\//i, "").replace(/^\/+/, "");
|
|
11458
|
+
const m = /^repos\/([^/]+)\/([^/?#]+)/i.exec(e);
|
|
11459
|
+
if (!m) return `${ghHost}/*`;
|
|
11460
|
+
if (m[1] === "{owner}" && m[2] === "{repo}") return void 0;
|
|
11461
|
+
return `${ghHost}/${m[1].toLowerCase()}/${m[2].toLowerCase()}`;
|
|
11462
|
+
}
|
|
11463
|
+
function sendToGitUrl(url, out) {
|
|
11464
|
+
out.sends = true;
|
|
11465
|
+
const h = typeof url === "string" ? host(url) : null;
|
|
11466
|
+
if (!url || !h) {
|
|
11467
|
+
out.unresolved = true;
|
|
11468
|
+
return;
|
|
11469
|
+
}
|
|
11470
|
+
out.destinations.push(h);
|
|
11471
|
+
const r = gitRepoPath(url);
|
|
11472
|
+
if (r) out.repos.push(r);
|
|
11473
|
+
}
|
|
11474
|
+
function callWords(call) {
|
|
11475
|
+
const raw = call.Args || [];
|
|
11476
|
+
if (raw.length === 0) return null;
|
|
11477
|
+
const words = raw.map((a) => resolveWordLiteral(a));
|
|
11478
|
+
const prefixes = raw.map((a) => resolveWordPrefix(a).prefix);
|
|
11479
|
+
const first = (words[0] || "").toLowerCase().split("/").pop() ?? "";
|
|
11480
|
+
const at = OWN_HEADS.has(first) ? 0 : unwrapCommandHead(words);
|
|
11481
|
+
const head = (words[at] || "").toLowerCase().split("/").pop() ?? "";
|
|
11482
|
+
if (!head) return null;
|
|
11483
|
+
const assigns = call.Assigns || [];
|
|
11484
|
+
const env = [
|
|
11485
|
+
...assigns.map((a) => String(a?.Name?.Value ?? "")),
|
|
11486
|
+
...words.slice(0, at).map((w) => w === null ? "" : /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(w)?.[1] ?? "")
|
|
11487
|
+
].filter(Boolean);
|
|
11488
|
+
return { head, args: words.slice(at + 1), prefixes: prefixes.slice(at + 1), env };
|
|
11489
|
+
}
|
|
11490
|
+
function flagValue(args, names) {
|
|
11491
|
+
for (let i = 0; i < args.length; i++) {
|
|
11492
|
+
const w = args[i];
|
|
11493
|
+
if (w === null) continue;
|
|
11494
|
+
for (const n of names) {
|
|
11495
|
+
if (w === n && typeof args[i + 1] === "string") return args[i + 1];
|
|
11496
|
+
if (w.startsWith(`${n}=`)) return w.slice(n.length + 1);
|
|
11497
|
+
}
|
|
11498
|
+
}
|
|
11499
|
+
return null;
|
|
11500
|
+
}
|
|
11501
|
+
function positionals(args, valueFlags) {
|
|
11502
|
+
const out = [];
|
|
11503
|
+
for (let i = 0; i < args.length; i++) {
|
|
11504
|
+
const w = args[i];
|
|
11505
|
+
if (w === null) {
|
|
11506
|
+
out.push(null);
|
|
11507
|
+
continue;
|
|
11508
|
+
}
|
|
11509
|
+
if (w === "--") {
|
|
11510
|
+
out.push(...args.slice(i + 1));
|
|
11511
|
+
break;
|
|
11512
|
+
}
|
|
11513
|
+
if (w.startsWith("-")) {
|
|
11514
|
+
if (!w.includes("=") && valueFlags.has(w)) i++;
|
|
11515
|
+
continue;
|
|
11516
|
+
}
|
|
11517
|
+
out.push(w);
|
|
11518
|
+
}
|
|
11519
|
+
return out;
|
|
11520
|
+
}
|
|
11521
|
+
function classifyCall(head, args, prefixes, env, state, out) {
|
|
11522
|
+
const lower2 = args.map((a) => a === null ? null : a.toLowerCase());
|
|
11523
|
+
switch (head) {
|
|
11524
|
+
case "curl":
|
|
11525
|
+
case "wget":
|
|
11526
|
+
case "iwr":
|
|
11527
|
+
case "invoke-webrequest":
|
|
11528
|
+
case "irm":
|
|
11529
|
+
case "invoke-restmethod": {
|
|
11530
|
+
const binary = head === "wget" ? "wget" : "curl";
|
|
11531
|
+
const sendFlags = head === "wget" ? WGET_SEND_FLAGS : head === "curl" ? CURL_SEND_FLAGS : IWR_SEND_FLAGS;
|
|
11532
|
+
let sends = false;
|
|
11533
|
+
for (let i = 0; i < args.length; i++) {
|
|
11534
|
+
const w = args[i];
|
|
11535
|
+
if (w === null) continue;
|
|
11536
|
+
const name = (head === "curl" || head === "wget" ? w : w.toLowerCase()).split("=")[0];
|
|
11537
|
+
if (sendFlags.has(name)) sends = true;
|
|
11538
|
+
const next = lower2[i + 1];
|
|
11539
|
+
if ((name === "-X" || name === "--request" || name === "-method") && next) {
|
|
11540
|
+
if (WRITE_METHODS.has(next)) sends = true;
|
|
11541
|
+
}
|
|
11542
|
+
if (/^(?:--request=|-X)(POST|PUT|PATCH|DELETE)$/i.test(w)) sends = true;
|
|
11543
|
+
if (name === "--method" && next && WRITE_METHODS.has(next)) sends = true;
|
|
11544
|
+
}
|
|
11545
|
+
const withPrefixes = args.map(
|
|
11546
|
+
(a, i) => a === null && /^[a-z][a-z0-9+.-]*:\/\//i.test(prefixes[i] ?? "") ? prefixes[i] : a
|
|
11547
|
+
);
|
|
11548
|
+
const dests = destTokensForBinary(binary, withPrefixes).map((t) => host(t)).filter((h) => h !== null);
|
|
11549
|
+
out.fetches = true;
|
|
11550
|
+
out.fetchKinds.push(head);
|
|
11551
|
+
out.fetchDestinations.push(...dests);
|
|
11552
|
+
if (sends) {
|
|
11553
|
+
out.sends = true;
|
|
11554
|
+
out.destinations.push(...dests);
|
|
11555
|
+
}
|
|
11556
|
+
return;
|
|
11557
|
+
}
|
|
11558
|
+
case "scp":
|
|
11559
|
+
case "rsync": {
|
|
11560
|
+
const pos = positionals(args, VALUE_FLAGS[head] ?? /* @__PURE__ */ new Set()).filter(
|
|
11561
|
+
(p) => p !== null
|
|
11562
|
+
);
|
|
11563
|
+
if (pos.length < 2) return;
|
|
11564
|
+
const remote = (p) => /^[a-z][a-z0-9+.-]*:\/\//i.test(p) || /^[^/]*[^/:]:[^/]/.test(p) || p.includes("@");
|
|
11565
|
+
const target = pos[pos.length - 1];
|
|
11566
|
+
const sources = pos.slice(0, -1);
|
|
11567
|
+
if (remote(target)) {
|
|
11568
|
+
out.sends = true;
|
|
11569
|
+
const h = host(target);
|
|
11570
|
+
if (h) out.destinations.push(h);
|
|
11571
|
+
}
|
|
11572
|
+
if (sources.some(remote)) {
|
|
11573
|
+
out.fetches = true;
|
|
11574
|
+
out.fetchKinds.push(head);
|
|
11575
|
+
for (const src of sources.filter(remote)) {
|
|
11576
|
+
const h = host(src);
|
|
11577
|
+
if (h) out.fetchDestinations.push(h);
|
|
11578
|
+
}
|
|
11579
|
+
}
|
|
11580
|
+
return;
|
|
11581
|
+
}
|
|
11582
|
+
case "nc":
|
|
11583
|
+
case "ncat":
|
|
11584
|
+
case "netcat":
|
|
11585
|
+
case "ssh": {
|
|
11586
|
+
out.fetches = true;
|
|
11587
|
+
out.sends = true;
|
|
11588
|
+
out.fetchKinds.push(head);
|
|
11589
|
+
for (const t of destTokensForBinary(head, args)) {
|
|
11590
|
+
const h = host(t);
|
|
11591
|
+
if (h) {
|
|
11592
|
+
out.destinations.push(h);
|
|
11593
|
+
out.fetchDestinations.push(h);
|
|
11594
|
+
}
|
|
11595
|
+
}
|
|
11596
|
+
return;
|
|
11597
|
+
}
|
|
11598
|
+
case "gh": {
|
|
11599
|
+
const pos = positionals(args, GH_HOSTNAME_FLAGS);
|
|
11600
|
+
const group = pos[0] ?? null;
|
|
11601
|
+
const verb = pos[1] ?? null;
|
|
11602
|
+
const hn = flagValue(args, ["--hostname"]);
|
|
11603
|
+
let dest = host(hn ?? "github.com") ?? "host:github.com";
|
|
11604
|
+
const ghHost = dest.slice("host:".length);
|
|
11605
|
+
const envRepo = env.some((n) => n === "GH_REPO" || n === "GH_HOST");
|
|
11606
|
+
if (group === "api") {
|
|
11607
|
+
const method = (flagValue(args, ["-X", "--method"]) ?? "get").toLowerCase();
|
|
11608
|
+
const hasBody = args.some(
|
|
11609
|
+
(w) => w !== null && /^(-f|--raw-field|-F|--field|--input)(=|$)/.test(w)
|
|
11610
|
+
);
|
|
11611
|
+
if (WRITE_METHODS.has(method) || hasBody) {
|
|
11612
|
+
out.sends = true;
|
|
11613
|
+
out.destinations.push(dest);
|
|
11614
|
+
const endpoint = positionals(args, GH_API_VALUE_FLAGS)[1] ?? null;
|
|
11615
|
+
const repo = ghApiRepo(endpoint, ghHost);
|
|
11616
|
+
if (repo !== void 0) out.repos.push(repo);
|
|
11617
|
+
else if (envRepo) out.repos.push(`${ghHost}/*`);
|
|
11618
|
+
} else {
|
|
11619
|
+
out.fetches = true;
|
|
11620
|
+
out.fetchKinds.push("gh api");
|
|
11621
|
+
out.fetchDestinations.push(dest);
|
|
11622
|
+
}
|
|
11623
|
+
return;
|
|
11624
|
+
}
|
|
11625
|
+
if (group === null || verb === null) return;
|
|
11626
|
+
if (GH_WRITE.has(verb)) {
|
|
11627
|
+
out.sends = true;
|
|
11628
|
+
const rIdx = args.findIndex((w) => w === "-R" || w === "--repo");
|
|
11629
|
+
const rEq = args.find((w) => w !== null && /^(-R|--repo)=/.test(w));
|
|
11630
|
+
const rVal = rEq !== void 0 && rEq !== null ? rEq.slice(rEq.indexOf("=") + 1) : rIdx >= 0 ? args[rIdx + 1] : void 0;
|
|
11631
|
+
let repo;
|
|
11632
|
+
if (rIdx >= 0 || rEq !== void 0) {
|
|
11633
|
+
if (typeof rVal === "string") {
|
|
11634
|
+
const named = ghRepoArg(rVal, ghHost);
|
|
11635
|
+
repo = named.repo;
|
|
11636
|
+
if (named.host !== ghHost) dest = `host:${named.host}`;
|
|
11637
|
+
} else repo = `${ghHost}/*`;
|
|
11638
|
+
} else if (group === "gist" || group === "repo" && (verb === "create" || verb === "fork")) {
|
|
11639
|
+
repo = `${ghHost}/*`;
|
|
11640
|
+
} else if (group === "repo" && verb !== "rename") {
|
|
11641
|
+
const operand = positionals(args, GH_REPO_VALUE_FLAGS)[2];
|
|
11642
|
+
if (operand === null) repo = `${ghHost}/*`;
|
|
11643
|
+
else if (operand !== void 0) repo = ghRepoArg(operand, ghHost).repo;
|
|
11644
|
+
else if (envRepo) repo = `${ghHost}/*`;
|
|
11645
|
+
} else if (envRepo) {
|
|
11646
|
+
repo = `${ghHost}/*`;
|
|
11647
|
+
}
|
|
11648
|
+
out.destinations.push(dest);
|
|
11649
|
+
if (repo !== void 0) out.repos.push(repo);
|
|
11650
|
+
} else if (GH_READ.has(verb)) {
|
|
11651
|
+
out.fetches = true;
|
|
11652
|
+
out.fetchKinds.push(`gh ${group}`);
|
|
11653
|
+
out.fetchDestinations.push(dest);
|
|
11654
|
+
}
|
|
11655
|
+
return;
|
|
11656
|
+
}
|
|
11657
|
+
case "git": {
|
|
11658
|
+
const pos = positionals(args, /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree"]));
|
|
11659
|
+
const verb = pos[0];
|
|
11660
|
+
if (verb === null || verb === void 0) return;
|
|
11661
|
+
for (let i = 0; i < args.length; i++) {
|
|
11662
|
+
if (args[i] !== "-c") continue;
|
|
11663
|
+
const v = args[i + 1];
|
|
11664
|
+
if (v === null || v === void 0) {
|
|
11665
|
+
if (verb === "push") out.unresolved = true;
|
|
11666
|
+
continue;
|
|
11667
|
+
}
|
|
11668
|
+
const m = /^remote\.[^=]+\.(?:push)?url=(.*)$/i.exec(v);
|
|
11669
|
+
if (m) sendToGitUrl(m[1], out);
|
|
11670
|
+
}
|
|
11671
|
+
if (verb === "remote") {
|
|
11672
|
+
const rp = positionals(args, /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "-t", "-m"]));
|
|
11673
|
+
const sub = rp[1];
|
|
11674
|
+
if (sub === "add" || sub === "set-url") {
|
|
11675
|
+
const url = rp.slice(2).filter((p) => p !== "--push" && p !== "--add")[1];
|
|
11676
|
+
sendToGitUrl(url, out);
|
|
11677
|
+
}
|
|
11678
|
+
return;
|
|
11679
|
+
}
|
|
11680
|
+
if (verb === "config") {
|
|
11681
|
+
const reads = args.some(
|
|
11682
|
+
(w) => w !== null && /^--(get|get-all|get-regexp|unset|unset-all|list|get-urlmatch)$/.test(w)
|
|
11683
|
+
);
|
|
11684
|
+
const k = pos.findIndex((p) => p !== null && /^remote\..+\.(?:push)?url$/i.test(p));
|
|
11685
|
+
if (k >= 0 && k + 1 < pos.length && !reads) sendToGitUrl(pos[k + 1], out);
|
|
11686
|
+
return;
|
|
11687
|
+
}
|
|
11688
|
+
if (GIT_FETCH.has(verb)) {
|
|
11689
|
+
out.fetches = true;
|
|
11690
|
+
out.fetchKinds.push(`git ${verb}`);
|
|
11691
|
+
for (const p of pos.slice(1)) {
|
|
11692
|
+
const h = p !== null && /:\/\/|@/.test(p) ? host(p) : null;
|
|
11693
|
+
if (h) out.fetchDestinations.push(h);
|
|
11694
|
+
}
|
|
11695
|
+
return;
|
|
11696
|
+
}
|
|
11697
|
+
if (verb === "push") {
|
|
11698
|
+
if (pos.length > 1 && pos[1] === null) {
|
|
11699
|
+
out.sends = true;
|
|
11700
|
+
out.unresolved = true;
|
|
11701
|
+
return;
|
|
11702
|
+
}
|
|
11703
|
+
const target = flagValue(args, ["--repo"]) ?? pos.slice(1).find((p) => p !== null && !p.startsWith("-")) ?? null;
|
|
11704
|
+
if (target !== null && (/:\/\/|@/.test(target) || /^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+:/.test(target))) {
|
|
11705
|
+
sendToGitUrl(target, out);
|
|
11706
|
+
return;
|
|
11707
|
+
}
|
|
11708
|
+
if (target !== null && /^[./~]|\//.test(target)) return;
|
|
11709
|
+
out.sends = true;
|
|
11710
|
+
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");
|
|
11711
|
+
if (elsewhere) out.unresolved = true;
|
|
11712
|
+
else out.gitRemotes.push(target ?? "");
|
|
11713
|
+
}
|
|
11714
|
+
return;
|
|
11715
|
+
}
|
|
11716
|
+
default: {
|
|
11717
|
+
const pub = PUBLISH[head];
|
|
11718
|
+
if (!pub) return;
|
|
11719
|
+
const pos = positionals(args, new Set(pub.flag ?? []));
|
|
11720
|
+
const verb = pos[0];
|
|
11721
|
+
if (verb === null || verb === void 0 || !pub.verbs.has(verb)) return;
|
|
11722
|
+
if (head === "yarn" && verb === "npm" && pos[1] !== "publish") return;
|
|
11723
|
+
out.sends = true;
|
|
11724
|
+
const named = pub.flag ? flagValue(args, pub.flag) : null;
|
|
11725
|
+
const h = named ? host(named) : null;
|
|
11726
|
+
if (named && !h) return;
|
|
11727
|
+
if (head === "docker") {
|
|
11728
|
+
const image = pos[1];
|
|
11729
|
+
const first = image?.split("/")[0] ?? "";
|
|
11730
|
+
const reg = first.includes(".") || first.includes(":") ? host(first) : null;
|
|
11731
|
+
out.destinations.push(reg ?? "host:docker.io");
|
|
11732
|
+
return;
|
|
11733
|
+
}
|
|
11734
|
+
out.destinations.push(h ?? `host:${pub.registry}`);
|
|
11735
|
+
}
|
|
11736
|
+
}
|
|
11737
|
+
}
|
|
11738
|
+
function walkCalls(command, out, depth, state) {
|
|
11739
|
+
const f = parseShared(command);
|
|
11740
|
+
if (typeof f === "symbol" || !f) return;
|
|
11741
|
+
syntax4.Walk(f, (node) => {
|
|
11742
|
+
if (!node) return false;
|
|
11743
|
+
const type = syntax4.NodeType(node);
|
|
11744
|
+
if (type === "DeclClause") {
|
|
11745
|
+
for (const a of node.Args || []) if (a?.Name?.Value) state.env.add(a.Name.Value);
|
|
11746
|
+
return true;
|
|
11747
|
+
}
|
|
11748
|
+
if (type !== "CallExpr") return true;
|
|
11749
|
+
const call = node;
|
|
11750
|
+
if ((call.Args || []).length === 0) {
|
|
11751
|
+
for (const a of call.Assigns || []) if (a?.Name?.Value) state.env.add(a.Name.Value);
|
|
11752
|
+
return true;
|
|
11753
|
+
}
|
|
11754
|
+
const c = callWords(node);
|
|
11755
|
+
if (!c) return true;
|
|
11756
|
+
if (SHELLS2.has(c.head) && depth < MAX_DEPTH3) {
|
|
11757
|
+
const i = c.args.findIndex((w) => w === "-c" || w === "-lc" || w === "-ec");
|
|
11758
|
+
const payload = i >= 0 ? c.args[i + 1] : null;
|
|
11759
|
+
if (typeof payload === "string") walkCalls(payload, out, depth + 1, state);
|
|
11760
|
+
return true;
|
|
11761
|
+
}
|
|
11762
|
+
if (CWD_CHANGERS.has(c.head)) state.cwdChanged = true;
|
|
11763
|
+
classifyCall(c.head, c.args, c.prefixes, [...c.env, ...state.env], state, out);
|
|
11764
|
+
return true;
|
|
11765
|
+
});
|
|
11766
|
+
}
|
|
11767
|
+
function classifyShellExposure(command) {
|
|
11768
|
+
const out = {
|
|
11769
|
+
...EMPTY,
|
|
11770
|
+
destinations: [],
|
|
11771
|
+
gitRemotes: [],
|
|
11772
|
+
repos: [],
|
|
11773
|
+
fetchDestinations: [],
|
|
11774
|
+
fetchKinds: []
|
|
11775
|
+
};
|
|
11776
|
+
try {
|
|
11777
|
+
walkCalls(command, out, 0, { cwdChanged: false, env: /* @__PURE__ */ new Set() });
|
|
11778
|
+
} catch {
|
|
11779
|
+
return { ...EMPTY };
|
|
11780
|
+
}
|
|
11781
|
+
out.destinations = [...new Set(out.destinations)];
|
|
11782
|
+
out.fetchDestinations = [...new Set(out.fetchDestinations)];
|
|
11783
|
+
out.gitRemotes = [...new Set(out.gitRemotes)];
|
|
11784
|
+
out.repos = [...new Set(out.repos)];
|
|
11785
|
+
out.fetchKinds = [...new Set(out.fetchKinds)];
|
|
11786
|
+
return out;
|
|
11787
|
+
}
|
|
11788
|
+
|
|
10821
11789
|
// src/utils/safe-text.ts
|
|
10822
11790
|
var TERMINAL_ESCAPE_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-_]|[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
|
|
10823
11791
|
var CONTROL_CHAR_RE = /[\x00-\x1F\x7F]/g;
|
|
@@ -11218,7 +12186,7 @@ function detectArgsPii(args) {
|
|
|
11218
12186
|
// src/dlp/canary.ts
|
|
11219
12187
|
var CANARY_MIN_LENGTH = 16;
|
|
11220
12188
|
var MAX_TEXT = 1e5;
|
|
11221
|
-
var
|
|
12189
|
+
var MAX_DEPTH4 = 6;
|
|
11222
12190
|
var MAX_JSON_PARSE = 1e4;
|
|
11223
12191
|
var URL_DEPTH = 4;
|
|
11224
12192
|
var B64_DEPTH = 3;
|
|
@@ -11341,8 +12309,8 @@ function matchCanaryArgs(args, values) {
|
|
|
11341
12309
|
if (values.length === 0) return null;
|
|
11342
12310
|
const needles = prepare(values);
|
|
11343
12311
|
if (needles.length === 0) return null;
|
|
11344
|
-
const
|
|
11345
|
-
if (depth >
|
|
12312
|
+
const walk2 = (v, depth, fieldPath) => {
|
|
12313
|
+
if (depth > MAX_DEPTH4) return null;
|
|
11346
12314
|
if (typeof v === "string") {
|
|
11347
12315
|
const hit = matchPrepared(v, needles);
|
|
11348
12316
|
if (hit) return { id: hit.v.id, view: hit.view, fieldPath, retired: Boolean(hit.v.retired) };
|
|
@@ -11350,31 +12318,31 @@ function matchCanaryArgs(args, values) {
|
|
|
11350
12318
|
const trimmed = v.trim();
|
|
11351
12319
|
if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
|
|
11352
12320
|
try {
|
|
11353
|
-
return
|
|
12321
|
+
return walk2(JSON.parse(v), depth + 1, fieldPath);
|
|
11354
12322
|
} catch {
|
|
11355
12323
|
}
|
|
11356
12324
|
}
|
|
11357
12325
|
}
|
|
11358
12326
|
return null;
|
|
11359
12327
|
}
|
|
11360
|
-
if (typeof v === "number" && Number.isFinite(v)) return
|
|
12328
|
+
if (typeof v === "number" && Number.isFinite(v)) return walk2(String(v), depth, fieldPath);
|
|
11361
12329
|
if (Array.isArray(v)) {
|
|
11362
12330
|
for (let i = 0; i < v.length; i++) {
|
|
11363
|
-
const h =
|
|
12331
|
+
const h = walk2(v[i], depth + 1, `${fieldPath}[${i}]`);
|
|
11364
12332
|
if (h) return h;
|
|
11365
12333
|
}
|
|
11366
12334
|
return null;
|
|
11367
12335
|
}
|
|
11368
12336
|
if (v && typeof v === "object") {
|
|
11369
12337
|
for (const [k, child] of Object.entries(v)) {
|
|
11370
|
-
const h =
|
|
12338
|
+
const h = walk2(child, depth + 1, fieldPath ? `${fieldPath}.${k}` : k);
|
|
11371
12339
|
if (h) return h;
|
|
11372
12340
|
}
|
|
11373
12341
|
}
|
|
11374
12342
|
return null;
|
|
11375
12343
|
};
|
|
11376
12344
|
try {
|
|
11377
|
-
return
|
|
12345
|
+
return walk2(args, 0, "");
|
|
11378
12346
|
} catch (e) {
|
|
11379
12347
|
console.error(
|
|
11380
12348
|
"[node9 engine] canary args walk failed:",
|
|
@@ -11386,8 +12354,8 @@ function matchCanaryArgs(args, values) {
|
|
|
11386
12354
|
|
|
11387
12355
|
// src/scan/canonical.ts
|
|
11388
12356
|
var LONG_OUTPUT_THRESHOLD_BYTES = 100 * 1024;
|
|
11389
|
-
var CANONICAL_EXTRACTOR_VERSION = "canonical-
|
|
11390
|
-
var CANONICAL_EXTRACTOR_HASH = "
|
|
12357
|
+
var CANONICAL_EXTRACTOR_VERSION = "canonical-v26";
|
|
12358
|
+
var CANONICAL_EXTRACTOR_HASH = "dec8c65145686360";
|
|
11391
12359
|
var DEDUPE_PREVIEW_LEN = 120;
|
|
11392
12360
|
function extractCanonicalFindings(call, ctx) {
|
|
11393
12361
|
const out = [];
|
|
@@ -11757,6 +12725,8 @@ function* stringValues(obj, depth = 0) {
|
|
|
11757
12725
|
// src/index.ts
|
|
11758
12726
|
var ENGINE_VERSION = "1.4.0";
|
|
11759
12727
|
export {
|
|
12728
|
+
AGENT_INSTRUCTION_DIRS,
|
|
12729
|
+
AGENT_INSTRUCTION_FILES,
|
|
11760
12730
|
ARGUMENT_SCAN_LIMITS,
|
|
11761
12731
|
AST_FS_REGEX_RULES,
|
|
11762
12732
|
BASH_TOOL_NAMES,
|
|
@@ -11789,6 +12759,7 @@ export {
|
|
|
11789
12759
|
LOOP_THRESHOLD_FOR_WASTE,
|
|
11790
12760
|
MAP_GOVERNED,
|
|
11791
12761
|
MAX_BLAST_PATH,
|
|
12762
|
+
MAX_DESTINATIONS,
|
|
11792
12763
|
NET_BINARIES,
|
|
11793
12764
|
PATTERN_VERB_NAMES,
|
|
11794
12765
|
PRIVILEGE_ESCALATION_RE,
|
|
@@ -11815,6 +12786,7 @@ export {
|
|
|
11815
12786
|
classifyAuditEntry,
|
|
11816
12787
|
classifyRuleSeverity,
|
|
11817
12788
|
classifyScanSignal,
|
|
12789
|
+
classifyShellExposure,
|
|
11818
12790
|
classifySsrf,
|
|
11819
12791
|
collectFileAccesses,
|
|
11820
12792
|
computeAgentDeviceScore,
|
|
@@ -11826,6 +12798,9 @@ export {
|
|
|
11826
12798
|
decodeEmbeddedBase64,
|
|
11827
12799
|
decodeEmbeddedHex,
|
|
11828
12800
|
dedupeCanonicalFindings,
|
|
12801
|
+
destinationDomain,
|
|
12802
|
+
destinationKind,
|
|
12803
|
+
destinationValue,
|
|
11829
12804
|
detectArgsPii,
|
|
11830
12805
|
detectDangerousEval,
|
|
11831
12806
|
detectDangerousShellExec,
|
|
@@ -11837,7 +12812,9 @@ export {
|
|
|
11837
12812
|
evaluateProtectedFileAccess,
|
|
11838
12813
|
evaluateSmartConditions,
|
|
11839
12814
|
extractAllSshHosts,
|
|
12815
|
+
extractArgDestinations,
|
|
11840
12816
|
extractCanonicalFindings,
|
|
12817
|
+
extractContentDestinations,
|
|
11841
12818
|
extractNetworkTargets,
|
|
11842
12819
|
extractPackageInstalls,
|
|
11843
12820
|
extractPositionalArgs,
|
|
@@ -11851,14 +12828,21 @@ export {
|
|
|
11851
12828
|
getCheck,
|
|
11852
12829
|
getCompiledRegex,
|
|
11853
12830
|
getNestedValue,
|
|
12831
|
+
gitRepoPath,
|
|
11854
12832
|
hostMatches,
|
|
11855
12833
|
incompleteFileVerdict,
|
|
11856
12834
|
inspectArgumentSecrets,
|
|
12835
|
+
inspectionEntry,
|
|
12836
|
+
inspectionLayers,
|
|
12837
|
+
isAgentInstructionPath,
|
|
11857
12838
|
isBashTool,
|
|
12839
|
+
isDestructiveToolName,
|
|
11858
12840
|
isIgnoredTool,
|
|
12841
|
+
isInside,
|
|
11859
12842
|
isKnobGoverned,
|
|
11860
12843
|
isLegacySystemPath,
|
|
11861
12844
|
isLockedCheck,
|
|
12845
|
+
isLoopbackHost,
|
|
11862
12846
|
isPasswordHashPath,
|
|
11863
12847
|
isPrivateHost,
|
|
11864
12848
|
isProtectedHomePath,
|