@resq-systems/security 1.0.5 → 2.0.0

package/lib/threats/engine.d.mts

@@ -0,0 +1,94 @@
+import { EventContext, ThreatContext, ThreatFinding, ThreatPolicy, ThreatSeverity, ThreatType, ThreatVerdict } from "./types.mjs";
+//#region src/threats/engine.d.ts
+/**
+ * Characters scanned before truncation.
+ *
+ * Bounds worst-case regex cost per call. Individual rules are bounded too — no
+ * unbounded nested quantifiers — so this is a second line of defense rather than the
+ * only one, but a 50 MB paste should not become a 50 MB × 89-rule scan regardless.
+ */
+declare const MAX_SCAN_LENGTH = 100000;
+/** Controls what {@link scanForThreats} evaluates and how it grades the outcome. */
+interface ThreatScanOptions {
+  /**
+   * Correlation metadata, echoed onto the result untouched.
+   *
+   * Affects nothing about detection. See {@link EventContext} for why it exists.
+   */
+  readonly event?: EventContext;
+  /**
+   * Sinks the value is destined for.
+   *
+   * Defaults to `["general_text"]`, which enables only the universal rules — bidi
+   * overrides, invisible characters, control characters. Any caller that wants
+   * injection detection must name the sink it is protecting; that requirement is
+   * the package's primary false-positive control, not an inconvenience.
+   */
+  readonly contexts?: readonly ThreatContext[];
+  /** Truncation bound. Defaults to {@link MAX_SCAN_LENGTH}. */
+  readonly maxLength?: number;
+  /**
+   * Scan encoded representations in addition to the raw string. Defaults to `true`.
+   * Pass `false` when the caller has already decoded the value and re-decoding
+   * would misrepresent it.
+   */
+  readonly scanVariants?: boolean;
+  /** Drop findings below this severity before scoring. Defaults to `"low"`. */
+  readonly minSeverity?: ThreatSeverity;
+  /**
+   * Rule IDs to skip. The tuning knob to reach for first: silencing one noisy rule
+   * on one route beats disabling a whole category.
+   */
+  readonly excludeRuleIds?: readonly string[];
+  /** Score thresholds. Defaults to {@link DEFAULT_THREAT_POLICY}. */
+  readonly policy?: ThreatPolicy;
+}
+/** Outcome of a scan. */
+interface ThreatScanResult {
+  /**
+   * The {@link EventContext} the caller supplied, echoed verbatim.
+   *
+   * Present only when one was passed. The scanner neither resolves nor validates it.
+   */
+  readonly event?: EventContext;
+  /** `true` when nothing fired at all — strictly stronger than `verdict === "allow"`. */
+  readonly isSafe: boolean;
+  /** Anomaly score. See {@link calculateThreatScore}. */
+  readonly score: number;
+  /** Policy band derived from {@link ThreatScanResult.score}. */
+  readonly verdict: ThreatVerdict;
+  /** Every finding, in catalog order then variant order. */
+  readonly findings: readonly ThreatFinding[];
+  /** Distinct weakness categories present, in first-seen order. */
+  readonly types: readonly ThreatType[];
+  /** `true` when the input exceeded `maxLength` and the tail went unscanned. */
+  readonly truncated: boolean;
+}
+/**
+ * Scan a value against the rules for its declared sinks.
+ *
+ * Every applicable rule is evaluated against every applicable representation, so the
+ * finding list may contain one rule more than once with different `variant` values.
+ * Scoring collapses those — see {@link calculateThreatScore} — so an encoded payload
+ * is not penalized twice merely for being encoded.
+ *
+ * Non-string input (`null`, `undefined`, a number) is reported safe rather than
+ * throwing: this is a detector, and rejecting the wrong *type* belongs to the
+ * caller's schema layer.
+ *
+ * @param input - The candidate value.
+ * @param options - Contexts and tuning. See {@link ThreatScanOptions}.
+ * @returns A {@link ThreatScanResult}. Never throws.
+ *
+ * @example Scoping to the actual sink
+ * ```ts
+ * const bio = "I maintain build scripts under C:\\Windows\\System32";
+ *
+ * scanForThreats(bio, { contexts: ["general_text"] }).verdict; // "allow"
+ * scanForThreats(bio, { contexts: ["filesystem"] }).verdict;   // "review"
+ * ```
+ */
+declare function scanForThreats(input: string, options?: ThreatScanOptions): ThreatScanResult;
+//#endregion
+export { MAX_SCAN_LENGTH, ThreatScanOptions, ThreatScanResult, scanForThreats };
+//# sourceMappingURL=engine.d.mts.map

package/lib/threats/engine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.mts","names":[],"sources":["../../src/threats/engine.ts"],"mappings":";;;;;;;;;cAwDa;;UAgBI;;;;;;WAMP,QAAQ;;;;;;;;;WASR,oBAAoB;;WAEpB;;;;;;WAMA;;WAEA,cAAc;;;;;WAKd;;WAEA,SAAS;;;UAIF;;;;;;WAMP,QAAQ;;WAER;;WAEA;;WAEA,SAAS;;WAET,mBAAmB;;WAEnB,gBAAgB;;WAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkFM,eAAe,eAAe,UAAS,oBAAyB"}

package/lib/threats/engine.mjs

@@ -0,0 +1,167 @@
+import { DEFAULT_THREAT_POLICY, SEVERITY_ORDER } from "./types.mjs";
+import { getRulesForContexts } from "./rules/index.mjs";
+import { calculateThreatScore, verdictForScore } from "./scoring.mjs";
+import { buildInputVariants } from "./variants.mjs";
+//#region src/threats/engine.ts
+/**
+* Copyright 2026 ResQ Systems, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* @fileoverview The scan engine: evaluate the rules applicable to a declared set of
+* sinks against a bounded set of input representations, then score the result.
+*
+* The engine's defining constraint is that **the caller must say where the value is
+* going**. Running every detector against every field is what makes signature-based
+* validation unusable in practice — a biography containing `C:\Windows`, a support
+* ticket containing `1=1`, and a programming question containing `eval(` are all
+* ordinary text, and only become evidence when the value actually reaches a
+* filesystem, SQL, or HTML sink. Declaring the context is the difference between a
+* detector that catches attacks and one that rejects customers.
+*
+* @module @resq-systems/security/threats/engine
+*/
+/**
+* Characters scanned before truncation.
+*
+* Bounds worst-case regex cost per call. Individual rules are bounded too — no
+* unbounded nested quantifiers — so this is a second line of defense rather than the
+* only one, but a 50 MB paste should not become a 50 MB × 89-rule scan regardless.
+*/
+const MAX_SCAN_LENGTH = 1e5;
+/** Matched substrings are truncated to this many characters before entering a finding. */
+const MAX_MATCH_EXCERPT = 50;
+/**
+* Run length at which a repeated single character is reported as resource abuse.
+* Set well above anything that occurs in prose or formatted text.
+*/
+const REPETITION_THRESHOLD = 200;
+/** Result returned for empty or non-string input. */
+const SAFE_RESULT = {
+	isSafe: true,
+	score: 0,
+	verdict: "allow",
+	findings: [],
+	types: [],
+	truncated: false
+};
+/**
+* Structural check that is cheaper and more informative computed than matched.
+*
+* A backreference like `/(.)\1{200,}/` expresses "long repeated run" but costs far
+* more than the single linear pass below, and the pass can report the actual run
+* length in the finding.
+*
+* @param value - Bounded input.
+* @returns At most one finding, for the first over-threshold run.
+*/
+function detectResourceAbuse(value) {
+	let runStart = 0;
+	for (let i = 1; i <= value.length; i++) {
+		if (i < value.length && value[i] === value[runStart]) continue;
+		const runLength = i - runStart;
+		if (runLength >= REPETITION_THRESHOLD) return [{
+			ruleId: "RESOURCE-REPETITION-001",
+			type: "resource_abuse",
+			severity: "medium",
+			confidence: "medium",
+			description: `Single character repeated ${runLength} times`,
+			cwe: 1333,
+			primaryControl: "Bound input length at the boundary and use linear-time matching (RE2) for untrusted patterns",
+			variant: "raw",
+			matchedPattern: value.slice(runStart, runStart + MAX_MATCH_EXCERPT),
+			start: runStart,
+			end: i
+		}];
+		runStart = i;
+	}
+	return [];
+}
+/**
+* Scan a value against the rules for its declared sinks.
+*
+* Every applicable rule is evaluated against every applicable representation, so the
+* finding list may contain one rule more than once with different `variant` values.
+* Scoring collapses those — see {@link calculateThreatScore} — so an encoded payload
+* is not penalized twice merely for being encoded.
+*
+* Non-string input (`null`, `undefined`, a number) is reported safe rather than
+* throwing: this is a detector, and rejecting the wrong *type* belongs to the
+* caller's schema layer.
+*
+* @param input - The candidate value.
+* @param options - Contexts and tuning. See {@link ThreatScanOptions}.
+* @returns A {@link ThreatScanResult}. Never throws.
+*
+* @example Scoping to the actual sink
+* ```ts
+* const bio = "I maintain build scripts under C:\\Windows\\System32";
+*
+* scanForThreats(bio, { contexts: ["general_text"] }).verdict; // "allow"
+* scanForThreats(bio, { contexts: ["filesystem"] }).verdict;   // "review"
+* ```
+*/
+function scanForThreats(input, options = {}) {
+	if (typeof input !== "string" || input.length === 0) return SAFE_RESULT;
+	const { contexts = ["general_text"], maxLength = MAX_SCAN_LENGTH, scanVariants = true, minSeverity = "low", excludeRuleIds, policy = DEFAULT_THREAT_POLICY } = options;
+	const truncated = input.length > maxLength;
+	const bounded = truncated ? input.slice(0, maxLength) : input;
+	const excluded = excludeRuleIds && excludeRuleIds.length > 0 ? new Set(excludeRuleIds) : null;
+	const severityFloor = SEVERITY_ORDER[minSeverity];
+	const rules = getRulesForContexts(contexts);
+	const variants = scanVariants ? buildInputVariants(bounded) : [{
+		kind: "raw",
+		value: bounded
+	}];
+	const findings = [];
+	for (const rule of rules) {
+		if (excluded?.has(rule.id)) continue;
+		if (SEVERITY_ORDER[rule.severity] < severityFloor) continue;
+		for (const variant of variants) {
+			if (rule.variants && !rule.variants.includes(variant.kind)) continue;
+			const match = rule.pattern.exec(variant.value);
+			if (match === null) continue;
+			findings.push({
+				ruleId: rule.id,
+				type: rule.type,
+				severity: rule.severity,
+				confidence: rule.confidence,
+				description: rule.description,
+				...rule.cwe === void 0 ? {} : { cwe: rule.cwe },
+				primaryControl: rule.primaryControl,
+				variant: variant.kind,
+				matchedPattern: match[0].slice(0, MAX_MATCH_EXCERPT),
+				start: match.index,
+				end: match.index + match[0].length
+			});
+		}
+	}
+	if (SEVERITY_ORDER.medium >= severityFloor && !excluded?.has("RESOURCE-REPETITION-001")) findings.push(...detectResourceAbuse(bounded));
+	const score = calculateThreatScore(findings);
+	const types = [];
+	for (const finding of findings) if (!types.includes(finding.type)) types.push(finding.type);
+	return {
+		isSafe: findings.length === 0,
+		score,
+		verdict: verdictForScore(score, policy),
+		findings,
+		types,
+		truncated,
+		...options.event === void 0 ? {} : { event: options.event }
+	};
+}
+//#endregion
+export { MAX_SCAN_LENGTH, scanForThreats };
+
+//# sourceMappingURL=engine.mjs.map

package/lib/threats/engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.mjs","names":[],"sources":["../../src/threats/engine.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ Systems, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview The scan engine: evaluate the rules applicable to a declared set of\n * sinks against a bounded set of input representations, then score the result.\n *\n * The engine's defining constraint is that **the caller must say where the value is\n * going**. Running every detector against every field is what makes signature-based\n * validation unusable in practice — a biography containing `C:\\Windows`, a support\n * ticket containing `1=1`, and a programming question containing `eval(` are all\n * ordinary text, and only become evidence when the value actually reaches a\n * filesystem, SQL, or HTML sink. Declaring the context is the difference between a\n * detector that catches attacks and one that rejects customers.\n *\n * @module @resq-systems/security/threats/engine\n */\n\nimport { getRulesForContexts } from \"./rules/index.js\";\nimport { calculateThreatScore, verdictForScore } from \"./scoring.js\";\nimport {\n\tDEFAULT_THREAT_POLICY,\n\ttype EventContext,\n\ttype InputVariant,\n\tSEVERITY_ORDER,\n\ttype ThreatContext,\n\ttype ThreatFinding,\n\ttype ThreatPolicy,\n\ttype ThreatSeverity,\n\ttype ThreatType,\n\ttype ThreatVerdict,\n} from \"./types.js\";\nimport { buildInputVariants } from \"./variants.js\";\n\n//#region Constants\n\n/**\n * Characters scanned before truncation.\n *\n * Bounds worst-case regex cost per call. Individual rules are bounded too — no\n * unbounded nested quantifiers — so this is a second line of defense rather than the\n * only one, but a 50 MB paste should not become a 50 MB × 89-rule scan regardless.\n */\nexport const MAX_SCAN_LENGTH = 100_000;\n\n/** Matched substrings are truncated to this many characters before entering a finding. */\nconst MAX_MATCH_EXCERPT = 50;\n\n/**\n * Run length at which a repeated single character is reported as resource abuse.\n * Set well above anything that occurs in prose or formatted text.\n */\nconst REPETITION_THRESHOLD = 200;\n\n//#endregion\n\n//#region Options and result\n\n/** Controls what {@link scanForThreats} evaluates and how it grades the outcome. */\nexport interface ThreatScanOptions {\n\t/**\n\t * Correlation metadata, echoed onto the result untouched.\n\t *\n\t * Affects nothing about detection. See {@link EventContext} for why it exists.\n\t */\n\treadonly event?: EventContext;\n\t/**\n\t * Sinks the value is destined for.\n\t *\n\t * Defaults to `[\"general_text\"]`, which enables only the universal rules — bidi\n\t * overrides, invisible characters, control characters. Any caller that wants\n\t * injection detection must name the sink it is protecting; that requirement is\n\t * the package's primary false-positive control, not an inconvenience.\n\t */\n\treadonly contexts?: readonly ThreatContext[];\n\t/** Truncation bound. Defaults to {@link MAX_SCAN_LENGTH}. */\n\treadonly maxLength?: number;\n\t/**\n\t * Scan encoded representations in addition to the raw string. Defaults to `true`.\n\t * Pass `false` when the caller has already decoded the value and re-decoding\n\t * would misrepresent it.\n\t */\n\treadonly scanVariants?: boolean;\n\t/** Drop findings below this severity before scoring. Defaults to `\"low\"`. */\n\treadonly minSeverity?: ThreatSeverity;\n\t/**\n\t * Rule IDs to skip. The tuning knob to reach for first: silencing one noisy rule\n\t * on one route beats disabling a whole category.\n\t */\n\treadonly excludeRuleIds?: readonly string[];\n\t/** Score thresholds. Defaults to {@link DEFAULT_THREAT_POLICY}. */\n\treadonly policy?: ThreatPolicy;\n}\n\n/** Outcome of a scan. */\nexport interface ThreatScanResult {\n\t/**\n\t * The {@link EventContext} the caller supplied, echoed verbatim.\n\t *\n\t * Present only when one was passed. The scanner neither resolves nor validates it.\n\t */\n\treadonly event?: EventContext;\n\t/** `true` when nothing fired at all — strictly stronger than `verdict === \"allow\"`. */\n\treadonly isSafe: boolean;\n\t/** Anomaly score. See {@link calculateThreatScore}. */\n\treadonly score: number;\n\t/** Policy band derived from {@link ThreatScanResult.score}. */\n\treadonly verdict: ThreatVerdict;\n\t/** Every finding, in catalog order then variant order. */\n\treadonly findings: readonly ThreatFinding[];\n\t/** Distinct weakness categories present, in first-seen order. */\n\treadonly types: readonly ThreatType[];\n\t/** `true` when the input exceeded `maxLength` and the tail went unscanned. */\n\treadonly truncated: boolean;\n}\n\n/** Result returned for empty or non-string input. */\nconst SAFE_RESULT: ThreatScanResult = {\n\tisSafe: true,\n\tscore: 0,\n\tverdict: \"allow\",\n\tfindings: [],\n\ttypes: [],\n\ttruncated: false,\n};\n\n//#endregion\n\n//#region Scanning\n\n/**\n * Structural check that is cheaper and more informative computed than matched.\n *\n * A backreference like `/(.)\\1{200,}/` expresses \"long repeated run\" but costs far\n * more than the single linear pass below, and the pass can report the actual run\n * length in the finding.\n *\n * @param value - Bounded input.\n * @returns At most one finding, for the first over-threshold run.\n */\nfunction detectResourceAbuse(value: string): ThreatFinding[] {\n\tlet runStart = 0;\n\n\tfor (let i = 1; i <= value.length; i++) {\n\t\tif (i < value.length && value[i] === value[runStart]) continue;\n\n\t\tconst runLength = i - runStart;\n\t\tif (runLength >= REPETITION_THRESHOLD) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\truleId: \"RESOURCE-REPETITION-001\",\n\t\t\t\t\ttype: \"resource_abuse\",\n\t\t\t\t\tseverity: \"medium\",\n\t\t\t\t\tconfidence: \"medium\",\n\t\t\t\t\tdescription: `Single character repeated ${runLength} times`,\n\t\t\t\t\tcwe: 1333,\n\t\t\t\t\tprimaryControl:\n\t\t\t\t\t\t\"Bound input length at the boundary and use linear-time matching (RE2) for untrusted patterns\",\n\t\t\t\t\tvariant: \"raw\",\n\t\t\t\t\tmatchedPattern: value.slice(runStart, runStart + MAX_MATCH_EXCERPT),\n\t\t\t\t\tstart: runStart,\n\t\t\t\t\tend: i,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\t\trunStart = i;\n\t}\n\n\treturn [];\n}\n\n/**\n * Scan a value against the rules for its declared sinks.\n *\n * Every applicable rule is evaluated against every applicable representation, so the\n * finding list may contain one rule more than once with different `variant` values.\n * Scoring collapses those — see {@link calculateThreatScore} — so an encoded payload\n * is not penalized twice merely for being encoded.\n *\n * Non-string input (`null`, `undefined`, a number) is reported safe rather than\n * throwing: this is a detector, and rejecting the wrong *type* belongs to the\n * caller's schema layer.\n *\n * @param input - The candidate value.\n * @param options - Contexts and tuning. See {@link ThreatScanOptions}.\n * @returns A {@link ThreatScanResult}. Never throws.\n *\n * @example Scoping to the actual sink\n * ```ts\n * const bio = \"I maintain build scripts under C:\\\\Windows\\\\System32\";\n *\n * scanForThreats(bio, { contexts: [\"general_text\"] }).verdict; // \"allow\"\n * scanForThreats(bio, { contexts: [\"filesystem\"] }).verdict;   // \"review\"\n * ```\n */\nexport function scanForThreats(input: string, options: ThreatScanOptions = {}): ThreatScanResult {\n\tif (typeof input !== \"string\" || input.length === 0) {\n\t\treturn SAFE_RESULT;\n\t}\n\n\tconst {\n\t\tcontexts = [\"general_text\"],\n\t\tmaxLength = MAX_SCAN_LENGTH,\n\t\tscanVariants = true,\n\t\tminSeverity = \"low\",\n\t\texcludeRuleIds,\n\t\tpolicy = DEFAULT_THREAT_POLICY,\n\t} = options;\n\n\tconst truncated = input.length > maxLength;\n\tconst bounded = truncated ? input.slice(0, maxLength) : input;\n\n\tconst excluded = excludeRuleIds && excludeRuleIds.length > 0 ? new Set(excludeRuleIds) : null;\n\tconst severityFloor = SEVERITY_ORDER[minSeverity];\n\n\tconst rules = getRulesForContexts(contexts);\n\tconst rawOnly: readonly InputVariant[] = [{ kind: \"raw\", value: bounded }];\n\tconst variants = scanVariants ? buildInputVariants(bounded) : rawOnly;\n\n\tconst findings: ThreatFinding[] = [];\n\n\tfor (const rule of rules) {\n\t\tif (excluded?.has(rule.id)) continue;\n\t\tif (SEVERITY_ORDER[rule.severity] < severityFloor) continue;\n\n\t\tfor (const variant of variants) {\n\t\t\tif (rule.variants && !rule.variants.includes(variant.kind)) continue;\n\n\t\t\t// Patterns are validated non-global at catalog load, so `exec` carries no\n\t\t\t// lastIndex state between calls and always matches from position 0.\n\t\t\tconst match = rule.pattern.exec(variant.value);\n\t\t\tif (match === null) continue;\n\n\t\t\tfindings.push({\n\t\t\t\truleId: rule.id,\n\t\t\t\ttype: rule.type,\n\t\t\t\tseverity: rule.severity,\n\t\t\t\tconfidence: rule.confidence,\n\t\t\t\tdescription: rule.description,\n\t\t\t\t...(rule.cwe === undefined ? {} : { cwe: rule.cwe }),\n\t\t\t\tprimaryControl: rule.primaryControl,\n\t\t\t\tvariant: variant.kind,\n\t\t\t\tmatchedPattern: match[0].slice(0, MAX_MATCH_EXCERPT),\n\t\t\t\tstart: match.index,\n\t\t\t\tend: match.index + match[0].length,\n\t\t\t});\n\t\t}\n\t}\n\n\tif (SEVERITY_ORDER.medium >= severityFloor && !excluded?.has(\"RESOURCE-REPETITION-001\")) {\n\t\tfindings.push(...detectResourceAbuse(bounded));\n\t}\n\n\tconst score = calculateThreatScore(findings);\n\n\tconst types: ThreatType[] = [];\n\tfor (const finding of findings) {\n\t\tif (!types.includes(finding.type)) types.push(finding.type);\n\t}\n\n\treturn {\n\t\tisSafe: findings.length === 0,\n\t\tscore,\n\t\tverdict: verdictForScore(score, policy),\n\t\tfindings,\n\t\ttypes,\n\t\ttruncated,\n\t\t...(options.event === undefined ? {} : { event: options.event }),\n\t};\n}\n\n//#endregion\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,kBAAkB;;AAG/B,MAAM,oBAAoB;;;;;AAM1B,MAAM,uBAAuB;;AAiE7B,MAAM,cAAgC;CACrC,QAAQ;CACR,OAAO;CACP,SAAS;CACT,UAAU,CAAC;CACX,OAAO,CAAC;CACR,WAAW;AACZ;;;;;;;;;;;AAgBA,SAAS,oBAAoB,OAAgC;CAC5D,IAAI,WAAW;CAEf,KAAK,IAAI,IAAI,GAAG,KAAK,MAAM,QAAQ,KAAK;EACvC,IAAI,IAAI,MAAM,UAAU,MAAM,OAAO,MAAM,WAAW;EAEtD,MAAM,YAAY,IAAI;EACtB,IAAI,aAAa,sBAChB,OAAO,CACN;GACC,QAAQ;GACR,MAAM;GACN,UAAU;GACV,YAAY;GACZ,aAAa,6BAA6B,UAAU;GACpD,KAAK;GACL,gBACC;GACD,SAAS;GACT,gBAAgB,MAAM,MAAM,UAAU,WAAW,iBAAiB;GAClE,OAAO;GACP,KAAK;EACN,CACD;EAED,WAAW;CACZ;CAEA,OAAO,CAAC;AACT;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,eAAe,OAAe,UAA6B,CAAC,GAAqB;CAChG,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GACjD,OAAO;CAGR,MAAM,EACL,WAAW,CAAC,cAAc,GAC1B,YAAY,iBACZ,eAAe,MACf,cAAc,OACd,gBACA,SAAS,0BACN;CAEJ,MAAM,YAAY,MAAM,SAAS;CACjC,MAAM,UAAU,YAAY,MAAM,MAAM,GAAG,SAAS,IAAI;CAExD,MAAM,WAAW,kBAAkB,eAAe,SAAS,IAAI,IAAI,IAAI,cAAc,IAAI;CACzF,MAAM,gBAAgB,eAAe;CAErC,MAAM,QAAQ,oBAAoB,QAAQ;CAE1C,MAAM,WAAW,eAAe,mBAAmB,OAAO,IAAI,CADpB;EAAE,MAAM;EAAO,OAAO;CAAQ,CACJ;CAEpE,MAAM,WAA4B,CAAC;CAEnC,KAAK,MAAM,QAAQ,OAAO;EACzB,IAAI,UAAU,IAAI,KAAK,EAAE,GAAG;EAC5B,IAAI,eAAe,KAAK,YAAY,eAAe;EAEnD,KAAK,MAAM,WAAW,UAAU;GAC/B,IAAI,KAAK,YAAY,CAAC,KAAK,SAAS,SAAS,QAAQ,IAAI,GAAG;GAI5D,MAAM,QAAQ,KAAK,QAAQ,KAAK,QAAQ,KAAK;GAC7C,IAAI,UAAU,MAAM;GAEpB,SAAS,KAAK;IACb,QAAQ,KAAK;IACb,MAAM,KAAK;IACX,UAAU,KAAK;IACf,YAAY,KAAK;IACjB,aAAa,KAAK;IAClB,GAAI,KAAK,QAAQ,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI;IAClD,gBAAgB,KAAK;IACrB,SAAS,QAAQ;IACjB,gBAAgB,MAAM,EAAE,CAAC,MAAM,GAAG,iBAAiB;IACnD,OAAO,MAAM;IACb,KAAK,MAAM,QAAQ,MAAM,EAAE,CAAC;GAC7B,CAAC;EACF;CACD;CAEA,IAAI,eAAe,UAAU,iBAAiB,CAAC,UAAU,IAAI,yBAAyB,GACrF,SAAS,KAAK,GAAG,oBAAoB,OAAO,CAAC;CAG9C,MAAM,QAAQ,qBAAqB,QAAQ;CAE3C,MAAM,QAAsB,CAAC;CAC7B,KAAK,MAAM,WAAW,UACrB,IAAI,CAAC,MAAM,SAAS,QAAQ,IAAI,GAAG,MAAM,KAAK,QAAQ,IAAI;CAG3D,OAAO;EACN,QAAQ,SAAS,WAAW;EAC5B;EACA,SAAS,gBAAgB,OAAO,MAAM;EACtC;EACA;EACA;EACA,GAAI,QAAQ,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO,QAAQ,MAAM;CAC/D;AACD"}

package/lib/threats/index.d.mts

@@ -0,0 +1,11 @@
+import { ALL_THREAT_CONTEXTS, CONFIDENCE_MULTIPLIERS, DEFAULT_THREAT_POLICY, EventContext, InputSource, InputVariant, InputVariantKind, SEVERITY_ORDER, SEVERITY_WEIGHTS, ThreatConfidence, ThreatContext, ThreatFinding, ThreatPolicy, ThreatRule, ThreatSeverity, ThreatType, ThreatVerdict } from "./types.mjs";
+import { MAX_SCAN_LENGTH, ThreatScanOptions, ThreatScanResult, scanForThreats } from "./engine.mjs";
+import { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES } from "./rules/datastore.mjs";
+import { PROMPT_INJECTION_RULES, TEMPLATE_INJECTION_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES } from "./rules/markup.mjs";
+import { COMMAND_INJECTION_RULES, FILE_INCLUSION_RULES, PATH_TRAVERSAL_RULES, SSRF_RULES } from "./rules/system.mjs";
+import { FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, LOG_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, XSS_RULES } from "./rules/web.mjs";
+import { THREAT_RULES, assertRuleCatalogIsValid, getRulesForContexts } from "./rules/index.mjs";
+import { ThreatTypeSummary, calculateThreatScore, scoreForFinding, summarizeByType, verdictForScore } from "./scoring.mjs";
+import { buildInputVariants, decodeHtmlEntities, tryPercentDecode } from "./variants.mjs";
+import { ATTACK_PATTERNS, AttackPattern, attackPatternsForCwe } from "./capec.generated.mjs";
+export { ALL_THREAT_CONTEXTS, ATTACK_PATTERNS, type AttackPattern, COMMAND_INJECTION_RULES, CONFIDENCE_MULTIPLIERS, DEFAULT_THREAT_POLICY, type EventContext, FILE_INCLUSION_RULES, FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, type InputSource, type InputVariant, type InputVariantKind, LDAP_INJECTION_RULES, LOG_INJECTION_RULES, MAX_SCAN_LENGTH, NOSQL_INJECTION_RULES, PATH_TRAVERSAL_RULES, PROMPT_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, SEVERITY_ORDER, SEVERITY_WEIGHTS, SQL_INJECTION_RULES, SSRF_RULES, TEMPLATE_INJECTION_RULES, THREAT_RULES, type ThreatConfidence, type ThreatContext, type ThreatFinding, type ThreatPolicy, type ThreatRule, type ThreatScanOptions, type ThreatScanResult, type ThreatSeverity, type ThreatType, type ThreatTypeSummary, type ThreatVerdict, UNIVERSAL_RULES, XML_INJECTION_RULES, XPATH_INJECTION_RULES, XSS_RULES, assertRuleCatalogIsValid, attackPatternsForCwe, buildInputVariants, calculateThreatScore, decodeHtmlEntities, getRulesForContexts, scanForThreats, scoreForFinding, summarizeByType, tryPercentDecode, verdictForScore };

package/lib/threats/index.mjs

@@ -0,0 +1,11 @@
+import { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES } from "./rules/datastore.mjs";
+import { ALL_THREAT_CONTEXTS, CONFIDENCE_MULTIPLIERS, DEFAULT_THREAT_POLICY, SEVERITY_ORDER, SEVERITY_WEIGHTS } from "./types.mjs";
+import { PROMPT_INJECTION_RULES, TEMPLATE_INJECTION_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES } from "./rules/markup.mjs";
+import { COMMAND_INJECTION_RULES, FILE_INCLUSION_RULES, PATH_TRAVERSAL_RULES, SSRF_RULES } from "./rules/system.mjs";
+import { FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, LOG_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, XSS_RULES } from "./rules/web.mjs";
+import { THREAT_RULES, assertRuleCatalogIsValid, getRulesForContexts } from "./rules/index.mjs";
+import { calculateThreatScore, scoreForFinding, summarizeByType, verdictForScore } from "./scoring.mjs";
+import { buildInputVariants, decodeHtmlEntities, tryPercentDecode } from "./variants.mjs";
+import { MAX_SCAN_LENGTH, scanForThreats } from "./engine.mjs";
+import { ATTACK_PATTERNS, attackPatternsForCwe } from "./capec.generated.mjs";
+export { ALL_THREAT_CONTEXTS, ATTACK_PATTERNS, COMMAND_INJECTION_RULES, CONFIDENCE_MULTIPLIERS, DEFAULT_THREAT_POLICY, FILE_INCLUSION_RULES, FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, LDAP_INJECTION_RULES, LOG_INJECTION_RULES, MAX_SCAN_LENGTH, NOSQL_INJECTION_RULES, PATH_TRAVERSAL_RULES, PROMPT_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, SEVERITY_ORDER, SEVERITY_WEIGHTS, SQL_INJECTION_RULES, SSRF_RULES, TEMPLATE_INJECTION_RULES, THREAT_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES, XPATH_INJECTION_RULES, XSS_RULES, assertRuleCatalogIsValid, attackPatternsForCwe, buildInputVariants, calculateThreatScore, decodeHtmlEntities, getRulesForContexts, scanForThreats, scoreForFinding, summarizeByType, tryPercentDecode, verdictForScore };

package/lib/threats/rules/datastore.d.mts

@@ -0,0 +1,13 @@
+import { ThreatRule } from "../types.mjs";
+//#region src/threats/rules/datastore.d.ts
+/** SQL-injection signatures. Scoped to the `sql` context. */
+declare const SQL_INJECTION_RULES: readonly ThreatRule[];
+/** Document-store operator injection (MongoDB and compatible drivers). */
+declare const NOSQL_INJECTION_RULES: readonly ThreatRule[];
+/** LDAP filter and DN injection. */
+declare const LDAP_INJECTION_RULES: readonly ThreatRule[];
+/** XPath/XQuery injection. */
+declare const XPATH_INJECTION_RULES: readonly ThreatRule[];
+//#endregion
+export { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES };
+//# sourceMappingURL=datastore.d.mts.map

package/lib/threats/rules/datastore.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.d.mts","names":[],"sources":["../../../src/threats/rules/datastore.ts"],"mappings":";;;cA4Ca,8BAA8B;;cA+O9B,gCAAgC;;cAyDhC,+BAA+B;;cA6E/B,gCAAgC"}