@resq-systems/security 1.0.5 → 2.0.0

package/lib/threats/rules/datastore.mjs

@@ -0,0 +1,366 @@
+//#region src/threats/rules/datastore.ts
+/** Repeated across every SQL rule. */
+const SQL_CONTROL = "Bind values as query parameters; never concatenate SQL strings";
+/** SQL-injection signatures. Scoped to the `sql` context. */
+const SQL_INJECTION_RULES = [
+	{
+		id: "SQL-UNION-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "UNION SELECT — classic result-set grafting",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bUNION\s+(?:ALL\s+)?SELECT\b/i
+	},
+	{
+		id: "SQL-DROP-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "critical",
+		confidence: "high",
+		description: "DROP of a schema object",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bDROP\s+(?:TABLE|DATABASE|SCHEMA|INDEX|VIEW|FUNCTION|PROCEDURE)\b/i
+	},
+	{
+		id: "SQL-DELETE-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "medium",
+		description: "DELETE FROM in a value position",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bDELETE\s+FROM\b/i
+	},
+	{
+		id: "SQL-TRUNCATE-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "medium",
+		description: "TRUNCATE TABLE in a value position",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bTRUNCATE\s+TABLE\b/i
+	},
+	{
+		id: "SQL-STACKED-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "Statement separator followed by a new statement",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /;\s{0,8}(?:SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|GRANT|EXEC|UNION)\b/i
+	},
+	{
+		id: "SQL-TAUTOLOGY-QUOTED-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "Quote-escaped always-true comparison",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /['"]\s{0,8}(?:OR|AND)\s+['"]?\w{1,20}['"]?\s{0,8}=\s{0,8}['"]?\w{1,20}/i
+	},
+	{
+		id: "SQL-TAUTOLOGY-NUMERIC-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "Quote- or paren-escaped numeric always-true comparison",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /['")]\s{0,8}(?:OR|AND)\s+\d{1,10}\s{0,8}=\s{0,8}\d{1,10}/i
+	},
+	{
+		id: "SQL-COMMENT-TERMINATOR-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "medium",
+		confidence: "low",
+		description: "Trailing SQL comment, used to truncate the rest of a statement",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /['")\d]\s{0,8}(?:--|#)[^\r\n]{0,64}$/
+	},
+	{
+		id: "SQL-VERSIONED-COMMENT-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "MySQL versioned comment, whose contents execute on MySQL only",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\/\*!\d{0,5}/
+	},
+	{
+		id: "SQL-COMMENT-INLINE-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "medium",
+		confidence: "low",
+		description: "Inline block comment, used to split keywords past naive filters",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\/\*[\s\S]{0,200}?\*\//
+	},
+	{
+		id: "SQL-COMMENT-SPLIT-KEYWORD-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "Inline comment separating two SQL keywords — keyword-filter evasion",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\b(?:UNION|SELECT|INSERT|UPDATE|DELETE|DROP|FROM|WHERE|ORDER|GROUP|HAVING|AND|OR)\s{0,8}\/\*[^*]{0,64}\*\/\s{0,8}(?:UNION|SELECT|ALL|DISTINCT|FROM|WHERE|INTO|TABLE|BY|\d|['"])/i
+	},
+	{
+		id: "SQL-TIME-BLIND-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "high",
+		description: "Time-delay function used for blind injection",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\b(?:SLEEP|PG_SLEEP|BENCHMARK)\s{0,8}\(|\bWAITFOR\s+DELAY\b/i
+	},
+	{
+		id: "SQL-METADATA-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "high",
+		confidence: "medium",
+		description: "Access to database metadata catalogs",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\b(?:INFORMATION_SCHEMA|pg_catalog|sysobjects|syscolumns|sqlite_master|all_tables)\b/i
+	},
+	{
+		id: "SQL-XP-PROC-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "critical",
+		confidence: "high",
+		description: "SQL Server extended procedure enabling OS access",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\b(?:xp_cmdshell|xp_regread|xp_regwrite|xp_dirtree|sp_oacreate)\b/i
+	},
+	{
+		id: "SQL-FILE-IO-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "critical",
+		confidence: "high",
+		description: "SQL file read/write primitive",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bINTO\s+(?:OUT|DUMP)FILE\b|\bLOAD_FILE\s{0,8}\(|\bCOPY\s+\w{1,64}\s+FROM\s+PROGRAM\b/i
+	},
+	{
+		id: "SQL-ENGINE-FILE-IO-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "critical",
+		confidence: "high",
+		description: "Engine-specific file read/write primitive",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bpg_(?:read_file|read_binary_file|ls_dir|stat_file)\s{0,8}\(|\blo_(?:import|export)\s{0,8}\(|\bOPENROWSET\s{0,8}\(|\bOPENDATASOURCE\s{0,8}\(|\bATTACH\s+DATABASE\b|\bUTL_FILE\s{0,8}\./i
+	},
+	{
+		id: "SQL-OUT-OF-BAND-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "critical",
+		confidence: "high",
+		description: "Out-of-band exfiltration or network primitive",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\bUTL_HTTP\s{0,8}\.|\bUTL_INADDR\s{0,8}\.|\bUTL_SMTP\s{0,8}\.|\bUTL_TCP\s{0,8}\.|\bDBMS_LDAP\s{0,8}\.|\bDBMS_PIPE\s{0,8}\.\s{0,8}RECEIVE_MESSAGE\b|\bdblink(?:_connect|_exec)?\s{0,8}\(/i
+	},
+	{
+		id: "SQL-HEX-LITERAL-001",
+		type: "sql_injection",
+		contexts: ["sql"],
+		severity: "low",
+		confidence: "low",
+		description: "Long hex literal, sometimes used to smuggle string constants",
+		cwe: 89,
+		primaryControl: SQL_CONTROL,
+		pattern: /\b0x[0-9a-f]{8,}\b/i
+	}
+];
+/** Repeated across every NoSQL rule. */
+const NOSQL_CONTROL = "Cast query values to primitives and reject object-valued inputs; never pass raw request bodies to a query builder";
+/** Document-store operator injection (MongoDB and compatible drivers). */
+const NOSQL_INJECTION_RULES = [
+	{
+		id: "NOSQL-OPERATOR-OBJECT-001",
+		type: "nosql_injection",
+		contexts: ["nosql"],
+		severity: "high",
+		confidence: "high",
+		description: "Object literal whose first key is a query operator",
+		cwe: 943,
+		primaryControl: NOSQL_CONTROL,
+		pattern: /\{\s{0,8}["']?\$[a-z]{2,20}["']?\s{0,8}:/i
+	},
+	{
+		id: "NOSQL-JS-EXECUTION-001",
+		type: "nosql_injection",
+		contexts: ["nosql"],
+		severity: "critical",
+		confidence: "high",
+		description: "Server-side JavaScript execution operator",
+		cwe: 943,
+		primaryControl: NOSQL_CONTROL,
+		pattern: /\$(?:where|function|accumulator)\s{0,8}["']?\s{0,8}:/i
+	},
+	{
+		id: "NOSQL-OPERATOR-001",
+		type: "nosql_injection",
+		contexts: ["nosql"],
+		severity: "medium",
+		confidence: "medium",
+		description: "Query operator token",
+		cwe: 943,
+		primaryControl: NOSQL_CONTROL,
+		pattern: /\$(?:gte?|lte?|ne|eq|nin?|and|or|not|nor|exists|type|mod|regex|text|all|elemMatch|size|slice|expr|jsonSchema)\b/i
+	},
+	{
+		id: "NOSQL-OPERATOR-ARRAY-001",
+		type: "nosql_injection",
+		contexts: ["nosql"],
+		severity: "medium",
+		confidence: "medium",
+		description: "Array subscript naming a query operator",
+		cwe: 943,
+		primaryControl: NOSQL_CONTROL,
+		pattern: /\[\s{0,8}["']?\$[a-z]{2,20}["']?\s{0,8}\]/i
+	}
+];
+/** Repeated across every LDAP rule. */
+const LDAP_CONTROL = "Escape filter values per RFC 4515 and DN components per RFC 4514 using the LDAP client's escaping helper";
+/** LDAP filter and DN injection. */
+const LDAP_INJECTION_RULES = [
+	{
+		id: "LDAP-FILTER-WILDCARD-001",
+		type: "ldap_injection",
+		contexts: ["ldap"],
+		severity: "high",
+		confidence: "high",
+		description: "Injected filter clause matching any value",
+		cwe: 90,
+		primaryControl: LDAP_CONTROL,
+		pattern: /[()&|!]\s{0,8}\(\s{0,8}[a-z0-9;.-]{1,64}\s{0,8}=\s{0,8}\*/i
+	},
+	{
+		id: "LDAP-FILTER-CLOSE-001",
+		type: "ldap_injection",
+		contexts: ["ldap"],
+		severity: "high",
+		confidence: "medium",
+		description: "Filter-terminating parenthesis followed by a boolean operator",
+		cwe: 90,
+		primaryControl: LDAP_CONTROL,
+		pattern: /\)\s{0,8}[&|]\s{0,8}\(/
+	},
+	{
+		id: "LDAP-METACHAR-001",
+		type: "ldap_injection",
+		contexts: ["ldap"],
+		severity: "medium",
+		confidence: "low",
+		description: "Unescaped LDAP filter metacharacter",
+		cwe: 90,
+		primaryControl: LDAP_CONTROL,
+		pattern: /[*()\\]/
+	},
+	{
+		id: "LDAP-DN-INJECTION-001",
+		type: "ldap_injection",
+		contexts: ["ldap"],
+		severity: "high",
+		confidence: "medium",
+		description: "RDN separator in a value destined for a distinguished name",
+		cwe: 90,
+		primaryControl: "Escape DN components per RFC 4514 using the LDAP client's DN escaping helper — filter escaping (RFC 4515) is a different function and does not cover these characters",
+		pattern: /[,+]\s{0,8}(?:cn|ou|dc|o|uid|sn|givenname|mail|member|objectclass)\s{0,8}=/i
+	},
+	{
+		id: "LDAP-DN-METACHAR-001",
+		type: "ldap_injection",
+		contexts: ["ldap"],
+		severity: "medium",
+		confidence: "low",
+		description: "Unescaped RFC 4514 distinguished-name metacharacter",
+		cwe: 90,
+		primaryControl: "Escape DN components per RFC 4514 using the LDAP client's DN escaping helper",
+		pattern: /["<>;]|^[+,]|[+,]$/
+	}
+];
+/** Repeated across every XPath rule. */
+const XPATH_CONTROL = "Use a precompiled XPath with variable binding (XPathVariableResolver or equivalent); never concatenate expressions";
+/** XPath/XQuery injection. */
+const XPATH_INJECTION_RULES = [
+	{
+		id: "XPATH-TAUTOLOGY-001",
+		type: "xpath_injection",
+		contexts: ["xpath"],
+		severity: "high",
+		confidence: "high",
+		description: "Quote-escaped always-true predicate",
+		cwe: 643,
+		primaryControl: XPATH_CONTROL,
+		pattern: /['"]\s{0,8}(?:or|and)\s+['"]?\w{1,20}['"]?\s{0,8}=\s{0,8}['"]?\w{1,20}/i
+	},
+	{
+		id: "XPATH-NODE-ESCAPE-001",
+		type: "xpath_injection",
+		contexts: ["xpath"],
+		severity: "high",
+		confidence: "high",
+		description: "Predicate closed then unioned with a new node path",
+		cwe: 643,
+		primaryControl: XPATH_CONTROL,
+		pattern: /\]\s{0,8}\|\s{0,8}\/{1,2}/
+	},
+	{
+		id: "XPATH-AXIS-001",
+		type: "xpath_injection",
+		contexts: ["xpath"],
+		severity: "medium",
+		confidence: "medium",
+		description: "Explicit XPath axis, used to walk outside the intended subtree",
+		cwe: 643,
+		primaryControl: XPATH_CONTROL,
+		pattern: /\b(?:ancestor|descendant|following|preceding|parent|child|self)(?:-or-self)?\s{0,8}::/i
+	},
+	{
+		id: "XPATH-FUNCTION-001",
+		type: "xpath_injection",
+		contexts: ["xpath"],
+		severity: "low",
+		confidence: "low",
+		description: "XPath function call in a value position",
+		cwe: 643,
+		primaryControl: XPATH_CONTROL,
+		pattern: /\b(?:count|name|local-name|namespace-uri|string-length|substring|position)\s{0,8}\(/i
+	}
+];
+//#endregion
+export { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES };
+
+//# sourceMappingURL=datastore.mjs.map

package/lib/threats/rules/datastore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.mjs","names":[],"sources":["../../../src/threats/rules/datastore.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 Query-language signatures: SQL, NoSQL/document-store operators,\n * LDAP filters, and XPath expressions.\n *\n * These are the rules most prone to false positives, because ordinary English and\n * ordinary source code contain SQL keywords constantly. Two mitigations apply:\n *\n * 1. Every rule is scoped to a query context, so none of them runs against a bio, a\n *    support ticket, or a search box whose value is bound as a parameter.\n * 2. Tautology rules require a quote or paren adjacent to the comparison, so the\n *    bare substring `1=1` — which occurs in perfectly ordinary arithmetic — no\n *    longer fires on its own. The previous catalog matched `/1\\s*=\\s*1/` outright.\n *\n * Detection here is telemetry. Parameterized queries are the control: a bound\n * parameter is safe no matter which keywords it contains, and an interpolated one is\n * unsafe no matter how many signatures it dodges.\n *\n * @module @resq-systems/security/threats/rules/datastore\n */\n\nimport type { ThreatRule } from \"../types.js\";\n\n//#region SQL\n\n/** Repeated across every SQL rule. */\nconst SQL_CONTROL = \"Bind values as query parameters; never concatenate SQL strings\";\n\n/** SQL-injection signatures. Scoped to the `sql` context. */\nexport const SQL_INJECTION_RULES: readonly ThreatRule[] = [\n\t{\n\t\tid: \"SQL-UNION-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"UNION SELECT — classic result-set grafting\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\bUNION\\s+(?:ALL\\s+)?SELECT\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-DROP-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"DROP of a schema object\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\bDROP\\s+(?:TABLE|DATABASE|SCHEMA|INDEX|VIEW|FUNCTION|PROCEDURE)\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-DELETE-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"DELETE FROM in a value position\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\bDELETE\\s+FROM\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-TRUNCATE-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"TRUNCATE TABLE in a value position\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\bTRUNCATE\\s+TABLE\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-STACKED-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Statement separator followed by a new statement\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /;\\s{0,8}(?:SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|GRANT|EXEC|UNION)\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-TAUTOLOGY-QUOTED-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Quote-escaped always-true comparison\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /['\"]\\s{0,8}(?:OR|AND)\\s+['\"]?\\w{1,20}['\"]?\\s{0,8}=\\s{0,8}['\"]?\\w{1,20}/i,\n\t},\n\t{\n\t\tid: \"SQL-TAUTOLOGY-NUMERIC-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Quote- or paren-escaped numeric always-true comparison\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// Requires the escape character. A bare `1=1` is ordinary arithmetic and is\n\t\t// deliberately *not* matched — that was the old catalog's worst false positive.\n\t\tpattern: /['\")]\\s{0,8}(?:OR|AND)\\s+\\d{1,10}\\s{0,8}=\\s{0,8}\\d{1,10}/i,\n\t},\n\t{\n\t\tid: \"SQL-COMMENT-TERMINATOR-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"Trailing SQL comment, used to truncate the rest of a statement\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// The comment must follow a quote, paren, or digit — the position it occupies\n\t\t// when it truncates an injected statement. A bare `(?:--|#)…$` fires on CSS\n\t\t// colours (`#ff00aa`), issue references (`#123`), and em-dash-style prose.\n\t\tpattern: /['\")\\d]\\s{0,8}(?:--|#)[^\\r\\n]{0,64}$/,\n\t},\n\t{\n\t\t// sqlmap ships this as its `versionedkeywords` tamper: MySQL executes the body of\n\t\t// a versioned comment while every other engine ignores it, so wrapping each\n\t\t// keyword hides the statement from a scanner looking for bare keywords. A value\n\t\t// reaching a SQL sink has no legitimate reason to contain one.\n\t\tid: \"SQL-VERSIONED-COMMENT-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"MySQL versioned comment, whose contents execute on MySQL only\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\/\\*!\\d{0,5}/,\n\t},\n\t{\n\t\tid: \"SQL-COMMENT-INLINE-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"Inline block comment, used to split keywords past naive filters\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\/\\*[\\s\\S]{0,200}?\\*\\//,\n\t},\n\t{\n\t\tid: \"SQL-COMMENT-SPLIT-KEYWORD-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Inline comment separating two SQL keywords — keyword-filter evasion\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// `1 UNION/**/SELECT/**/1` defeats SQL-UNION-001, which requires whitespace\n\t\t// between the keywords, and previously scored only 1.0 from the generic\n\t\t// inline-comment rule — an `allow` verdict on a working injection. A comment\n\t\t// *between two keywords* has no benign explanation in a bound value, so this is\n\t\t// graded high/high where the bare-comment rule stays low/low.\n\t\tpattern:\n\t\t\t/\\b(?:UNION|SELECT|INSERT|UPDATE|DELETE|DROP|FROM|WHERE|ORDER|GROUP|HAVING|AND|OR)\\s{0,8}\\/\\*[^*]{0,64}\\*\\/\\s{0,8}(?:UNION|SELECT|ALL|DISTINCT|FROM|WHERE|INTO|TABLE|BY|\\d|['\"])/i,\n\t},\n\t{\n\t\tid: \"SQL-TIME-BLIND-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Time-delay function used for blind injection\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\b(?:SLEEP|PG_SLEEP|BENCHMARK)\\s{0,8}\\(|\\bWAITFOR\\s+DELAY\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-METADATA-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"Access to database metadata catalogs\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern:\n\t\t\t/\\b(?:INFORMATION_SCHEMA|pg_catalog|sysobjects|syscolumns|sqlite_master|all_tables)\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-XP-PROC-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"SQL Server extended procedure enabling OS access\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern: /\\b(?:xp_cmdshell|xp_regread|xp_regwrite|xp_dirtree|sp_oacreate)\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-FILE-IO-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"SQL file read/write primitive\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\tpattern:\n\t\t\t/\\bINTO\\s+(?:OUT|DUMP)FILE\\b|\\bLOAD_FILE\\s{0,8}\\(|\\bCOPY\\s+\\w{1,64}\\s+FROM\\s+PROGRAM\\b/i,\n\t},\n\t{\n\t\tid: \"SQL-ENGINE-FILE-IO-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Engine-specific file read/write primitive\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// SQL-FILE-IO-001 covers only the MySQL forms. Every primitive below scanned\n\t\t// clean unless the payload happened to carry a `;`, in which case\n\t\t// SQL-STACKED-001 caught it incidentally — remove the semicolon and each was\n\t\t// 0/allow.\n\t\tpattern:\n\t\t\t/\\bpg_(?:read_file|read_binary_file|ls_dir|stat_file)\\s{0,8}\\(|\\blo_(?:import|export)\\s{0,8}\\(|\\bOPENROWSET\\s{0,8}\\(|\\bOPENDATASOURCE\\s{0,8}\\(|\\bATTACH\\s+DATABASE\\b|\\bUTL_FILE\\s{0,8}\\./i,\n\t},\n\t{\n\t\tid: \"SQL-OUT-OF-BAND-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Out-of-band exfiltration or network primitive\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// Oracle's network packages and Postgres dblink are the standard out-of-band\n\t\t// channels for blind injection: they make the database itself perform the\n\t\t// exfiltration, so no data need come back through the response.\n\t\tpattern:\n\t\t\t/\\bUTL_HTTP\\s{0,8}\\.|\\bUTL_INADDR\\s{0,8}\\.|\\bUTL_SMTP\\s{0,8}\\.|\\bUTL_TCP\\s{0,8}\\.|\\bDBMS_LDAP\\s{0,8}\\.|\\bDBMS_PIPE\\s{0,8}\\.\\s{0,8}RECEIVE_MESSAGE\\b|\\bdblink(?:_connect|_exec)?\\s{0,8}\\(/i,\n\t},\n\t{\n\t\tid: \"SQL-HEX-LITERAL-001\",\n\t\ttype: \"sql_injection\",\n\t\tcontexts: [\"sql\"],\n\t\tseverity: \"low\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"Long hex literal, sometimes used to smuggle string constants\",\n\t\tcwe: 89,\n\t\tprimaryControl: SQL_CONTROL,\n\t\t// Bounded at 8+ digits so ordinary colour codes (`0xFF00AA`) and short\n\t\t// constants do not fire. The old catalog used `/0x[0-9a-f]+/`, which matched\n\t\t// every CSS colour in the corpus.\n\t\tpattern: /\\b0x[0-9a-f]{8,}\\b/i,\n\t},\n];\n\n//#endregion\n\n//#region NoSQL\n\n/** Repeated across every NoSQL rule. */\nconst NOSQL_CONTROL =\n\t\"Cast query values to primitives and reject object-valued inputs; never pass raw request bodies to a query builder\";\n\n/** Document-store operator injection (MongoDB and compatible drivers). */\nexport const NOSQL_INJECTION_RULES: readonly ThreatRule[] = [\n\t{\n\t\tid: \"NOSQL-OPERATOR-OBJECT-001\",\n\t\ttype: \"nosql_injection\",\n\t\tcontexts: [\"nosql\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Object literal whose first key is a query operator\",\n\t\tcwe: 943,\n\t\tprimaryControl: NOSQL_CONTROL,\n\t\tpattern: /\\{\\s{0,8}[\"']?\\$[a-z]{2,20}[\"']?\\s{0,8}:/i,\n\t},\n\t{\n\t\tid: \"NOSQL-JS-EXECUTION-001\",\n\t\ttype: \"nosql_injection\",\n\t\tcontexts: [\"nosql\"],\n\t\tseverity: \"critical\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Server-side JavaScript execution operator\",\n\t\tcwe: 943,\n\t\tprimaryControl: NOSQL_CONTROL,\n\t\tpattern: /\\$(?:where|function|accumulator)\\s{0,8}[\"']?\\s{0,8}:/i,\n\t},\n\t{\n\t\tid: \"NOSQL-OPERATOR-001\",\n\t\ttype: \"nosql_injection\",\n\t\tcontexts: [\"nosql\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"Query operator token\",\n\t\tcwe: 943,\n\t\tprimaryControl: NOSQL_CONTROL,\n\t\tpattern:\n\t\t\t/\\$(?:gte?|lte?|ne|eq|nin?|and|or|not|nor|exists|type|mod|regex|text|all|elemMatch|size|slice|expr|jsonSchema)\\b/i,\n\t},\n\t{\n\t\tid: \"NOSQL-OPERATOR-ARRAY-001\",\n\t\ttype: \"nosql_injection\",\n\t\tcontexts: [\"nosql\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"Array subscript naming a query operator\",\n\t\tcwe: 943,\n\t\tprimaryControl: NOSQL_CONTROL,\n\t\tpattern: /\\[\\s{0,8}[\"']?\\$[a-z]{2,20}[\"']?\\s{0,8}\\]/i,\n\t},\n];\n\n//#endregion\n\n//#region LDAP\n\n/** Repeated across every LDAP rule. */\nconst LDAP_CONTROL =\n\t\"Escape filter values per RFC 4515 and DN components per RFC 4514 using the LDAP client's escaping helper\";\n\n/** LDAP filter and DN injection. */\nexport const LDAP_INJECTION_RULES: readonly ThreatRule[] = [\n\t{\n\t\tid: \"LDAP-FILTER-WILDCARD-001\",\n\t\ttype: \"ldap_injection\",\n\t\tcontexts: [\"ldap\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Injected filter clause matching any value\",\n\t\tcwe: 90,\n\t\tprimaryControl: LDAP_CONTROL,\n\t\tpattern: /[()&|!]\\s{0,8}\\(\\s{0,8}[a-z0-9;.-]{1,64}\\s{0,8}=\\s{0,8}\\*/i,\n\t},\n\t{\n\t\tid: \"LDAP-FILTER-CLOSE-001\",\n\t\ttype: \"ldap_injection\",\n\t\tcontexts: [\"ldap\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"Filter-terminating parenthesis followed by a boolean operator\",\n\t\tcwe: 90,\n\t\tprimaryControl: LDAP_CONTROL,\n\t\tpattern: /\\)\\s{0,8}[&|]\\s{0,8}\\(/,\n\t},\n\t{\n\t\tid: \"LDAP-METACHAR-001\",\n\t\ttype: \"ldap_injection\",\n\t\tcontexts: [\"ldap\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"Unescaped LDAP filter metacharacter\",\n\t\tcwe: 90,\n\t\tprimaryControl: LDAP_CONTROL,\n\t\tpattern: /[*()\\\\]/,\n\t},\n\t{\n\t\tid: \"LDAP-DN-INJECTION-001\",\n\t\ttype: \"ldap_injection\",\n\t\tcontexts: [\"ldap\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"RDN separator in a value destined for a distinguished name\",\n\t\tcwe: 90,\n\t\tprimaryControl:\n\t\t\t\"Escape DN components per RFC 4514 using the LDAP client's DN escaping helper — filter escaping (RFC 4515) is a different function and does not cover these characters\",\n\t\t// The filter rules above cover RFC 4515 metacharacters (`*`, parens, backslash).\n\t\t// A DN uses a different grammar entirely: `,` and `+` separate relative\n\t\t// distinguished names, so `admin,ou=admins,dc=example,dc=com` re-parents the\n\t\t// entry. All three DN forms scanned 0/allow before this rule.\n\t\t// Confidence is medium because a common name can legitimately contain a comma\n\t\t// (\"Smith, John\") — which is exactly why it must be escaped, not rejected.\n\t\tpattern: /[,+]\\s{0,8}(?:cn|ou|dc|o|uid|sn|givenname|mail|member|objectclass)\\s{0,8}=/i,\n\t},\n\t{\n\t\tid: \"LDAP-DN-METACHAR-001\",\n\t\ttype: \"ldap_injection\",\n\t\tcontexts: [\"ldap\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"Unescaped RFC 4514 distinguished-name metacharacter\",\n\t\tcwe: 90,\n\t\tprimaryControl: \"Escape DN components per RFC 4514 using the LDAP client's DN escaping helper\",\n\t\t// Leading/trailing space and `#` are also special in a DN, but flagging them\n\t\t// would fire on nearly every human name, so only the structural characters are\n\t\t// listed here.\n\t\tpattern: /[\"<>;]|^[+,]|[+,]$/,\n\t},\n];\n\n//#endregion\n\n//#region XPath\n\n/** Repeated across every XPath rule. */\nconst XPATH_CONTROL =\n\t\"Use a precompiled XPath with variable binding (XPathVariableResolver or equivalent); never concatenate expressions\";\n\n/** XPath/XQuery injection. */\nexport const XPATH_INJECTION_RULES: readonly ThreatRule[] = [\n\t{\n\t\tid: \"XPATH-TAUTOLOGY-001\",\n\t\ttype: \"xpath_injection\",\n\t\tcontexts: [\"xpath\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Quote-escaped always-true predicate\",\n\t\tcwe: 643,\n\t\tprimaryControl: XPATH_CONTROL,\n\t\tpattern: /['\"]\\s{0,8}(?:or|and)\\s+['\"]?\\w{1,20}['\"]?\\s{0,8}=\\s{0,8}['\"]?\\w{1,20}/i,\n\t},\n\t{\n\t\tid: \"XPATH-NODE-ESCAPE-001\",\n\t\ttype: \"xpath_injection\",\n\t\tcontexts: [\"xpath\"],\n\t\tseverity: \"high\",\n\t\tconfidence: \"high\",\n\t\tdescription: \"Predicate closed then unioned with a new node path\",\n\t\tcwe: 643,\n\t\tprimaryControl: XPATH_CONTROL,\n\t\tpattern: /\\]\\s{0,8}\\|\\s{0,8}\\/{1,2}/,\n\t},\n\t{\n\t\tid: \"XPATH-AXIS-001\",\n\t\ttype: \"xpath_injection\",\n\t\tcontexts: [\"xpath\"],\n\t\tseverity: \"medium\",\n\t\tconfidence: \"medium\",\n\t\tdescription: \"Explicit XPath axis, used to walk outside the intended subtree\",\n\t\tcwe: 643,\n\t\tprimaryControl: XPATH_CONTROL,\n\t\tpattern:\n\t\t\t/\\b(?:ancestor|descendant|following|preceding|parent|child|self)(?:-or-self)?\\s{0,8}::/i,\n\t},\n\t{\n\t\tid: \"XPATH-FUNCTION-001\",\n\t\ttype: \"xpath_injection\",\n\t\tcontexts: [\"xpath\"],\n\t\tseverity: \"low\",\n\t\tconfidence: \"low\",\n\t\tdescription: \"XPath function call in a value position\",\n\t\tcwe: 643,\n\t\tprimaryControl: XPATH_CONTROL,\n\t\tpattern: /\\b(?:count|name|local-name|namespace-uri|string-length|substring|position)\\s{0,8}\\(/i,\n\t},\n];\n\n//#endregion\n"],"mappings":"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"}

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

@@ -0,0 +1,54 @@
+import { ThreatContext, ThreatRule } from "../types.mjs";
+import { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES } from "./datastore.mjs";
+import { PROMPT_INJECTION_RULES, TEMPLATE_INJECTION_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES } from "./markup.mjs";
+import { CREDENTIAL_EXPOSURE_RULES, DOUBLE_ENCODING_RULES, JWT_RULES, PARAMETER_POLLUTION_RULES } from "./protocol.mjs";
+import { COMMAND_INJECTION_RULES, FILE_INCLUSION_RULES, PATH_TRAVERSAL_RULES, SSRF_RULES } from "./system.mjs";
+import { FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, LOG_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, XSS_RULES } from "./web.mjs";
+//#region src/threats/rules/index.d.ts
+/**
+ * Every signature the engine knows about, in a stable order.
+ *
+ * Order affects only the sequence of findings in a result — scoring is
+ * order-independent.
+ */
+declare const THREAT_RULES: readonly ThreatRule[];
+/**
+ * Assert the catalog's structural invariants.
+ *
+ * Runs once at module load and throws on violation — see the file overview for why
+ * these are fatal rather than warnings.
+ *
+ * @param rules - Catalog to validate. Defaults to {@link THREAT_RULES}.
+ * @throws {Error} If any rule has a duplicate ID, an empty context list, or a
+ *   stateful (`g`/`y`) pattern. The message lists every problem found, not just the
+ *   first.
+ */
+declare function assertRuleCatalogIsValid(rules?: readonly ThreatRule[]): void;
+/**
+ * Rule IDs that once shipped and have since been withdrawn.
+ *
+ * A rule ID is public API: consumers pin them in `excludeRuleIds` to suppress a finding
+ * they have accepted. Reusing a retired ID silently re-points that suppression at an
+ * unrelated rule, which is worse than the original finding because nobody is looking.
+ * Add the ID here when a rule is withdrawn; never remove an entry.
+ *
+ * Enforced from the test suite rather than from {@link assertRuleCatalogIsValid}: that
+ * runs at module load in every consumer process, and its checks are fatal because they
+ * are runtime-correctness failures. This one is release hygiene.
+ */
+declare const RETIRED_RULE_IDS: readonly string[];
+/**
+ * Collect the rules applicable to a set of sinks.
+ *
+ * A rule declaring several contexts is returned once even when the caller names more
+ * than one of them, so a value bound for both `html` and `url` is not double-scored
+ * by a scheme rule that covers both.
+ *
+ * @param contexts - Sinks the value is destined for.
+ * @returns Deduplicated rules in {@link THREAT_RULES} order — stable regardless of
+ *   the order the caller listed contexts in.
+ */
+declare function getRulesForContexts(contexts: readonly ThreatContext[]): readonly ThreatRule[];
+//#endregion
+export { COMMAND_INJECTION_RULES, CREDENTIAL_EXPOSURE_RULES, DOUBLE_ENCODING_RULES, FILE_INCLUSION_RULES, FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, JWT_RULES, LDAP_INJECTION_RULES, LOG_INJECTION_RULES, NOSQL_INJECTION_RULES, PARAMETER_POLLUTION_RULES, PATH_TRAVERSAL_RULES, PROMPT_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, RETIRED_RULE_IDS, SQL_INJECTION_RULES, SSRF_RULES, TEMPLATE_INJECTION_RULES, THREAT_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES, XPATH_INJECTION_RULES, XSS_RULES, assertRuleCatalogIsValid, getRulesForContexts };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/threats/rules/index.ts"],"mappings":";;;;;;;;;;;;;cA4Ea,uBAAuB;;;;;;;;;;;;iBAuCpB,yBAAyB,iBAAgB;;;;;;;;;;;;;cAyE5C;;;;;;;;;;;;iBAaG,oBAAoB,mBAAmB,2BAA2B"}

package/lib/threats/rules/index.mjs

@@ -0,0 +1,121 @@
+import { LDAP_INJECTION_RULES, NOSQL_INJECTION_RULES, SQL_INJECTION_RULES, XPATH_INJECTION_RULES } from "./datastore.mjs";
+import { PROMPT_INJECTION_RULES, TEMPLATE_INJECTION_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES } from "./markup.mjs";
+import { CREDENTIAL_EXPOSURE_RULES, DOUBLE_ENCODING_RULES, JWT_RULES, PARAMETER_POLLUTION_RULES } from "./protocol.mjs";
+import { COMMAND_INJECTION_RULES, FILE_INCLUSION_RULES, PATH_TRAVERSAL_RULES, SSRF_RULES } from "./system.mjs";
+import { FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, LOG_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, XSS_RULES } from "./web.mjs";
+//#region src/threats/rules/index.ts
+/**
+* Every signature the engine knows about, in a stable order.
+*
+* Order affects only the sequence of findings in a result — scoring is
+* order-independent.
+*/
+const THREAT_RULES = [
+	...XSS_RULES,
+	...PROTOTYPE_POLLUTION_RULES,
+	...HEADER_INJECTION_RULES,
+	...FORMULA_INJECTION_RULES,
+	...LOG_INJECTION_RULES,
+	...SQL_INJECTION_RULES,
+	...NOSQL_INJECTION_RULES,
+	...LDAP_INJECTION_RULES,
+	...XPATH_INJECTION_RULES,
+	...COMMAND_INJECTION_RULES,
+	...PATH_TRAVERSAL_RULES,
+	...FILE_INCLUSION_RULES,
+	...SSRF_RULES,
+	...XML_INJECTION_RULES,
+	...TEMPLATE_INJECTION_RULES,
+	...PROMPT_INJECTION_RULES,
+	...PARAMETER_POLLUTION_RULES,
+	...CREDENTIAL_EXPOSURE_RULES,
+	...JWT_RULES,
+	...DOUBLE_ENCODING_RULES,
+	...UNIVERSAL_RULES
+];
+/**
+* Assert the catalog's structural invariants.
+*
+* Runs once at module load and throws on violation — see the file overview for why
+* these are fatal rather than warnings.
+*
+* @param rules - Catalog to validate. Defaults to {@link THREAT_RULES}.
+* @throws {Error} If any rule has a duplicate ID, an empty context list, or a
+*   stateful (`g`/`y`) pattern. The message lists every problem found, not just the
+*   first.
+*/
+function assertRuleCatalogIsValid(rules = THREAT_RULES) {
+	const seen = /* @__PURE__ */ new Set();
+	const problems = [];
+	for (const rule of rules) {
+		if (seen.has(rule.id)) problems.push(`duplicate rule id: ${rule.id}`);
+		seen.add(rule.id);
+		if (rule.contexts.length === 0) problems.push(`${rule.id}: contexts must not be empty`);
+		if (rule.pattern.global || rule.pattern.sticky) problems.push(`${rule.id}: pattern must not use the g or y flag (lastIndex makes matching stateful)`);
+	}
+	if (problems.length > 0) throw new Error(`Invalid threat rule catalog:\n  ${problems.join("\n  ")}`);
+}
+assertRuleCatalogIsValid();
+/**
+* Index from context to the rules that declare it, built once at module load so
+* per-call scanning is a map lookup rather than a filter over the whole catalog.
+*/
+const RULES_BY_CONTEXT = (() => {
+	const index = /* @__PURE__ */ new Map();
+	for (const rule of THREAT_RULES) for (const context of rule.contexts) {
+		const bucket = index.get(context);
+		if (bucket) bucket.push(rule);
+		else index.set(context, [rule]);
+	}
+	return index;
+})();
+/**
+* Memoized results of {@link getRulesForContexts} for multi-context calls.
+*
+* Keyed by the sorted, deduplicated, known-only context list, so it holds at most one
+* entry per distinct subset of the context enum — a hard ceiling that does not depend on
+* caller behaviour. The single-context path never reaches here; it already returns a
+* prebuilt bucket from {@link RULES_BY_CONTEXT}.
+*/
+const COMBINATION_CACHE = /* @__PURE__ */ new Map();
+/**
+* Rule IDs that once shipped and have since been withdrawn.
+*
+* A rule ID is public API: consumers pin them in `excludeRuleIds` to suppress a finding
+* they have accepted. Reusing a retired ID silently re-points that suppression at an
+* unrelated rule, which is worse than the original finding because nobody is looking.
+* Add the ID here when a rule is withdrawn; never remove an entry.
+*
+* Enforced from the test suite rather than from {@link assertRuleCatalogIsValid}: that
+* runs at module load in every consumer process, and its checks are fatal because they
+* are runtime-correctness failures. This one is release hygiene.
+*/
+const RETIRED_RULE_IDS = [];
+/**
+* Collect the rules applicable to a set of sinks.
+*
+* A rule declaring several contexts is returned once even when the caller names more
+* than one of them, so a value bound for both `html` and `url` is not double-scored
+* by a scheme rule that covers both.
+*
+* @param contexts - Sinks the value is destined for.
+* @returns Deduplicated rules in {@link THREAT_RULES} order — stable regardless of
+*   the order the caller listed contexts in.
+*/
+function getRulesForContexts(contexts) {
+	const first = contexts[0];
+	if (contexts.length === 1 && first !== void 0) return RULES_BY_CONTEXT.get(first) ?? [];
+	const known = [...new Set(contexts)].filter((context) => RULES_BY_CONTEXT.has(context)).sort();
+	const key = known.join(" ");
+	const cached = COMBINATION_CACHE.get(key);
+	if (cached !== void 0) return cached;
+	const selected = /* @__PURE__ */ new Set();
+	for (const context of known) for (const rule of RULES_BY_CONTEXT.get(context) ?? []) selected.add(rule);
+	const computed = THREAT_RULES.filter((rule) => selected.has(rule));
+	COMBINATION_CACHE.set(key, computed);
+	return computed;
+}
+//#endregion
+export { COMMAND_INJECTION_RULES, CREDENTIAL_EXPOSURE_RULES, DOUBLE_ENCODING_RULES, FILE_INCLUSION_RULES, FORMULA_INJECTION_RULES, HEADER_INJECTION_RULES, JWT_RULES, LDAP_INJECTION_RULES, LOG_INJECTION_RULES, NOSQL_INJECTION_RULES, PARAMETER_POLLUTION_RULES, PATH_TRAVERSAL_RULES, PROMPT_INJECTION_RULES, PROTOTYPE_POLLUTION_RULES, RETIRED_RULE_IDS, SQL_INJECTION_RULES, SSRF_RULES, TEMPLATE_INJECTION_RULES, THREAT_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES, XPATH_INJECTION_RULES, XSS_RULES, assertRuleCatalogIsValid, getRulesForContexts };
+
+//# sourceMappingURL=index.mjs.map

package/lib/threats/rules/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/threats/rules/index.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 complete threat-rule catalog, assembled from the per-domain\n * groups and validated at module load.\n *\n * Validation is deliberately eager and fatal. A duplicate rule ID would make findings\n * ambiguous and break per-rule tuning; a stateful (`/g` or `/y`) pattern would make\n * detection depend on how many times the module had been called before. Both are\n * programming errors in the catalog itself rather than runtime conditions, so they\n * throw at import instead of degrading silently in production.\n *\n * @module @resq-systems/security/threats/rules\n */\n\nimport type { ThreatContext, ThreatRule } from \"../types.js\";\nimport {\n\tLDAP_INJECTION_RULES,\n\tNOSQL_INJECTION_RULES,\n\tSQL_INJECTION_RULES,\n\tXPATH_INJECTION_RULES,\n} from \"./datastore.js\";\nimport {\n\tPROMPT_INJECTION_RULES,\n\tTEMPLATE_INJECTION_RULES,\n\tUNIVERSAL_RULES,\n\tXML_INJECTION_RULES,\n} from \"./markup.js\";\nimport {\n\tCREDENTIAL_EXPOSURE_RULES,\n\tDOUBLE_ENCODING_RULES,\n\tJWT_RULES,\n\tPARAMETER_POLLUTION_RULES,\n} from \"./protocol.js\";\nimport {\n\tCOMMAND_INJECTION_RULES,\n\tFILE_INCLUSION_RULES,\n\tPATH_TRAVERSAL_RULES,\n\tSSRF_RULES,\n} from \"./system.js\";\nimport {\n\tFORMULA_INJECTION_RULES,\n\tHEADER_INJECTION_RULES,\n\tLOG_INJECTION_RULES,\n\tPROTOTYPE_POLLUTION_RULES,\n\tXSS_RULES,\n} from \"./web.js\";\n\nexport * from \"./datastore.js\";\nexport * from \"./markup.js\";\nexport * from \"./protocol.js\";\nexport * from \"./system.js\";\nexport * from \"./web.js\";\n\n//#region Catalog\n\n/**\n * Every signature the engine knows about, in a stable order.\n *\n * Order affects only the sequence of findings in a result — scoring is\n * order-independent.\n */\nexport const THREAT_RULES: readonly ThreatRule[] = [\n\t...XSS_RULES,\n\t...PROTOTYPE_POLLUTION_RULES,\n\t...HEADER_INJECTION_RULES,\n\t...FORMULA_INJECTION_RULES,\n\t...LOG_INJECTION_RULES,\n\t...SQL_INJECTION_RULES,\n\t...NOSQL_INJECTION_RULES,\n\t...LDAP_INJECTION_RULES,\n\t...XPATH_INJECTION_RULES,\n\t...COMMAND_INJECTION_RULES,\n\t...PATH_TRAVERSAL_RULES,\n\t...FILE_INCLUSION_RULES,\n\t...SSRF_RULES,\n\t...XML_INJECTION_RULES,\n\t...TEMPLATE_INJECTION_RULES,\n\t...PROMPT_INJECTION_RULES,\n\t...PARAMETER_POLLUTION_RULES,\n\t...CREDENTIAL_EXPOSURE_RULES,\n\t...JWT_RULES,\n\t...DOUBLE_ENCODING_RULES,\n\t...UNIVERSAL_RULES,\n];\n\n//#endregion\n\n//#region Validation\n\n/**\n * Assert the catalog's structural invariants.\n *\n * Runs once at module load and throws on violation — see the file overview for why\n * these are fatal rather than warnings.\n *\n * @param rules - Catalog to validate. Defaults to {@link THREAT_RULES}.\n * @throws {Error} If any rule has a duplicate ID, an empty context list, or a\n *   stateful (`g`/`y`) pattern. The message lists every problem found, not just the\n *   first.\n */\nexport function assertRuleCatalogIsValid(rules: readonly ThreatRule[] = THREAT_RULES): void {\n\tconst seen = new Set<string>();\n\tconst problems: string[] = [];\n\n\tfor (const rule of rules) {\n\t\tif (seen.has(rule.id)) {\n\t\t\tproblems.push(`duplicate rule id: ${rule.id}`);\n\t\t}\n\t\tseen.add(rule.id);\n\n\t\tif (rule.contexts.length === 0) {\n\t\t\tproblems.push(`${rule.id}: contexts must not be empty`);\n\t\t}\n\n\t\tif (rule.pattern.global || rule.pattern.sticky) {\n\t\t\tproblems.push(\n\t\t\t\t`${rule.id}: pattern must not use the g or y flag (lastIndex makes matching stateful)`,\n\t\t\t);\n\t\t}\n\t}\n\n\tif (problems.length > 0) {\n\t\tthrow new Error(`Invalid threat rule catalog:\\n  ${problems.join(\"\\n  \")}`);\n\t}\n}\n\nassertRuleCatalogIsValid();\n\n//#endregion\n\n//#region Lookup\n\n/**\n * Index from context to the rules that declare it, built once at module load so\n * per-call scanning is a map lookup rather than a filter over the whole catalog.\n */\nconst RULES_BY_CONTEXT: ReadonlyMap<ThreatContext, readonly ThreatRule[]> = (() => {\n\tconst index = new Map<ThreatContext, ThreatRule[]>();\n\tfor (const rule of THREAT_RULES) {\n\t\tfor (const context of rule.contexts) {\n\t\t\tconst bucket = index.get(context);\n\t\t\tif (bucket) {\n\t\t\t\tbucket.push(rule);\n\t\t\t} else {\n\t\t\t\tindex.set(context, [rule]);\n\t\t\t}\n\t\t}\n\t}\n\treturn index;\n})();\n\n/**\n * Memoized results of {@link getRulesForContexts} for multi-context calls.\n *\n * Keyed by the sorted, deduplicated, known-only context list, so it holds at most one\n * entry per distinct subset of the context enum — a hard ceiling that does not depend on\n * caller behaviour. The single-context path never reaches here; it already returns a\n * prebuilt bucket from {@link RULES_BY_CONTEXT}.\n */\nconst COMBINATION_CACHE = new Map<string, readonly ThreatRule[]>();\n\n/**\n * Rule IDs that once shipped and have since been withdrawn.\n *\n * A rule ID is public API: consumers pin them in `excludeRuleIds` to suppress a finding\n * they have accepted. Reusing a retired ID silently re-points that suppression at an\n * unrelated rule, which is worse than the original finding because nobody is looking.\n * Add the ID here when a rule is withdrawn; never remove an entry.\n *\n * Enforced from the test suite rather than from {@link assertRuleCatalogIsValid}: that\n * runs at module load in every consumer process, and its checks are fatal because they\n * are runtime-correctness failures. This one is release hygiene.\n */\nexport const RETIRED_RULE_IDS: readonly string[] = [];\n\n/**\n * Collect the rules applicable to a set of sinks.\n *\n * A rule declaring several contexts is returned once even when the caller names more\n * than one of them, so a value bound for both `html` and `url` is not double-scored\n * by a scheme rule that covers both.\n *\n * @param contexts - Sinks the value is destined for.\n * @returns Deduplicated rules in {@link THREAT_RULES} order — stable regardless of\n *   the order the caller listed contexts in.\n */\nexport function getRulesForContexts(contexts: readonly ThreatContext[]): readonly ThreatRule[] {\n\tconst first = contexts[0];\n\tif (contexts.length === 1 && first !== undefined) {\n\t\treturn RULES_BY_CONTEXT.get(first) ?? [];\n\t}\n\n\t// The result is a pure function of the context set, so this re-derived the same\n\t// array on every call: ~214 Set insertions plus a 132-element filter allocation,\n\t// which on short inputs was a third of total scan time.\n\t//\n\t// The key is deduplicated, filtered to contexts the catalog knows, and sorted.\n\t// Sorting preserves the documented order-independence. The other two steps bound\n\t// the cache: this function is exported publicly, so a JavaScript caller can pass\n\t// arbitrary strings, and keying on those unfiltered would let any caller grow the\n\t// map without limit. An unknown context contributes no rules, so dropping it\n\t// cannot change the result -- it only collapses [\"html\", \"nonsense\"] onto\n\t// [\"html\"], which is the same answer. Keys are therefore subsets of a 19-member set.\n\tconst known = [...new Set(contexts)].filter((context) => RULES_BY_CONTEXT.has(context)).sort();\n\tconst key = known.join(\" \");\n\tconst cached = COMBINATION_CACHE.get(key);\n\tif (cached !== undefined) return cached;\n\n\tconst selected = new Set<ThreatRule>();\n\tfor (const context of known) {\n\t\tfor (const rule of RULES_BY_CONTEXT.get(context) ?? []) {\n\t\t\tselected.add(rule);\n\t\t}\n\t}\n\n\tconst computed = THREAT_RULES.filter((rule) => selected.has(rule));\n\tCOMBINATION_CACHE.set(key, computed);\n\treturn computed;\n}\n\n//#endregion\n"],"mappings":";;;;;;;;;;;;AA4EA,MAAa,eAAsC;CAClD,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACJ;;;;;;;;;;;;AAiBA,SAAgB,yBAAyB,QAA+B,cAAoB;CAC3F,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,WAAqB,CAAC;CAE5B,KAAK,MAAM,QAAQ,OAAO;EACzB,IAAI,KAAK,IAAI,KAAK,EAAE,GACnB,SAAS,KAAK,sBAAsB,KAAK,IAAI;EAE9C,KAAK,IAAI,KAAK,EAAE;EAEhB,IAAI,KAAK,SAAS,WAAW,GAC5B,SAAS,KAAK,GAAG,KAAK,GAAG,6BAA6B;EAGvD,IAAI,KAAK,QAAQ,UAAU,KAAK,QAAQ,QACvC,SAAS,KACR,GAAG,KAAK,GAAG,2EACZ;CAEF;CAEA,IAAI,SAAS,SAAS,GACrB,MAAM,IAAI,MAAM,mCAAmC,SAAS,KAAK,MAAM,GAAG;AAE5E;AAEA,yBAAyB;;;;;AAUzB,MAAM,0BAA6E;CAClF,MAAM,wBAAQ,IAAI,IAAiC;CACnD,KAAK,MAAM,QAAQ,cAClB,KAAK,MAAM,WAAW,KAAK,UAAU;EACpC,MAAM,SAAS,MAAM,IAAI,OAAO;EAChC,IAAI,QACH,OAAO,KAAK,IAAI;OAEhB,MAAM,IAAI,SAAS,CAAC,IAAI,CAAC;CAE3B;CAED,OAAO;AACR,EAAA,CAAG;;;;;;;;;AAUH,MAAM,oCAAoB,IAAI,IAAmC;;;;;;;;;;;;;AAcjE,MAAa,mBAAsC,CAAC;;;;;;;;;;;;AAapD,SAAgB,oBAAoB,UAA2D;CAC9F,MAAM,QAAQ,SAAS;CACvB,IAAI,SAAS,WAAW,KAAK,UAAU,KAAA,GACtC,OAAO,iBAAiB,IAAI,KAAK,KAAK,CAAC;CAcxC,MAAM,QAAQ,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,QAAQ,YAAY,iBAAiB,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK;CAC7F,MAAM,MAAM,MAAM,KAAK,GAAG;CAC1B,MAAM,SAAS,kBAAkB,IAAI,GAAG;CACxC,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,2BAAW,IAAI,IAAgB;CACrC,KAAK,MAAM,WAAW,OACrB,KAAK,MAAM,QAAQ,iBAAiB,IAAI,OAAO,KAAK,CAAC,GACpD,SAAS,IAAI,IAAI;CAInB,MAAM,WAAW,aAAa,QAAQ,SAAS,SAAS,IAAI,IAAI,CAAC;CACjE,kBAAkB,IAAI,KAAK,QAAQ;CACnC,OAAO;AACR"}

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

@@ -0,0 +1,28 @@
+import { ThreatRule } from "../types.mjs";
+//#region src/threats/rules/markup.d.ts
+/** XML external entity and entity-expansion signatures. */
+declare const XML_INJECTION_RULES: readonly ThreatRule[];
+/** Server-side template injection and SSI directives. */
+declare const TEMPLATE_INJECTION_RULES: readonly ThreatRule[];
+/**
+ * LLM prompt injection.
+ *
+ * These are the weakest signatures in the catalog by construction — prompt injection
+ * is expressed in natural language, so no finite pattern set bounds it. They are
+ * graded accordingly (mostly `medium` confidence) and are useful as telemetry and as
+ * a tripwire for human review, never as an authorization decision.
+ */
+declare const PROMPT_INJECTION_RULES: readonly ThreatRule[];
+/**
+ * Rules that apply in every context, including `general_text`.
+ *
+ * The bar for membership is high: a rule belongs here only if there is no legitimate
+ * reason for the character to appear in *any* user-supplied value. Bidirectional
+ * overrides (the "Trojan Source" class, CVE-2021-42574), zero-width characters used
+ * to spoof identity, and C0 control characters all clear it. SQL keywords and `../`
+ * emphatically do not, which is why they are context-scoped instead.
+ */
+declare const UNIVERSAL_RULES: readonly ThreatRule[];
+//#endregion
+export { PROMPT_INJECTION_RULES, TEMPLATE_INJECTION_RULES, UNIVERSAL_RULES, XML_INJECTION_RULES };
+//# sourceMappingURL=markup.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markup.d.mts","names":[],"sources":["../../../src/threats/rules/markup.ts"],"mappings":";;;cAuCa,8BAA8B;;cAmE9B,mCAAmC;;;;;;;;;cA0KnC,iCAAiC;;;;;;;;;;cAgHjC,0BAA0B"}