@bryan-thompson/inspector-assessment-client 1.26.4 → 1.26.6

package/lib/services/assessment/modules/securityTests/MathAnalyzer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Math Analyzer
+ * Detects computed math expression results (Calculator Injection)
+ *
+ * Extracted from SecurityResponseAnalyzer.ts (Issue #53)
+ * Handles: math computation detection, coincidental numeric detection
+ */
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Result of computed math analysis with confidence level (Issue #58)
+ */
+export interface MathResultAnalysis {
+    isComputed: boolean;
+    confidence: "high" | "medium" | "low";
+    reason?: string;
+}
+/**
+ * Analyzes tool responses for math computation evidence (Calculator Injection)
+ */
+export declare class MathAnalyzer {
+    /**
+     * Enhanced computed math result analysis with tool context (Issue #58)
+     *
+     * Returns a confidence level indicating how likely this is a real Calculator Injection:
+     * - high: Strong evidence of computation (should flag as vulnerable)
+     * - medium: Ambiguous (excluded from vulnerability count per user decision)
+     * - low: Likely coincidental data (excluded from vulnerability count)
+     */
+    analyzeComputedMathResult(payload: string, responseText: string, tool?: Tool): MathResultAnalysis;
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use analyzeComputedMathResult instead
+     */
+    isComputedMathResult(payload: string, responseText: string): boolean;
+    /**
+     * Check if numeric value appears in structured data context (not as computation result)
+     * Distinguishes {"records": 4} from computed "4" (Issue #58)
+     *
+     * @param result The computed numeric result to check for
+     * @param responseText The response text to analyze
+     * @returns true if the number appears to be coincidental data, not a computed result
+     */
+    isCoincidentalNumericInStructuredData(result: number, responseText: string): boolean;
+    /**
+     * Recursively check JSON object for coincidental numeric values
+     */
+    private checkObjectForCoincidentalNumeric;
+    /**
+     * Check text for structured patterns containing coincidental numerics
+     */
+    private checkTextForCoincidentalNumeric;
+    /**
+     * Compute math expression from regex match
+     * Returns null if invalid operator
+     */
+    private computeExpression;
+}
+//# sourceMappingURL=MathAnalyzer.d.ts.map

package/lib/services/assessment/modules/securityTests/MathAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathAnalyzer.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/securityTests/MathAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAW1D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;;;OAOG;IACH,yBAAyB,CACvB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,IAAI,GACV,kBAAkB;IAkIrB;;;OAGG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAKpE;;;;;;;OAOG;IACH,qCAAqC,CACnC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO;IAWV;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAyCzC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAqBvC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;CA+C1B"}

package/lib/services/assessment/modules/securityTests/MathAnalyzer.js

@@ -0,0 +1,251 @@
+/**
+ * Math Analyzer
+ * Detects computed math expression results (Calculator Injection)
+ *
+ * Extracted from SecurityResponseAnalyzer.ts (Issue #53)
+ * Handles: math computation detection, coincidental numeric detection
+ */
+import { ToolClassifier, ToolCategory } from "../../ToolClassifier.js";
+import { SIMPLE_MATH_PATTERN, COMPUTATIONAL_INDICATORS, STRUCTURED_DATA_FIELD_NAMES, READ_ONLY_TOOL_NAME_PATTERN, isHttpError, matchesAny, } from "./SecurityPatternLibrary.js";
+/**
+ * Analyzes tool responses for math computation evidence (Calculator Injection)
+ */
+export class MathAnalyzer {
+    /**
+     * Enhanced computed math result analysis with tool context (Issue #58)
+     *
+     * Returns a confidence level indicating how likely this is a real Calculator Injection:
+     * - high: Strong evidence of computation (should flag as vulnerable)
+     * - medium: Ambiguous (excluded from vulnerability count per user decision)
+     * - low: Likely coincidental data (excluded from vulnerability count)
+     */
+    analyzeComputedMathResult(payload, responseText, tool) {
+        // Skip HTTP error responses
+        if (isHttpError(responseText)) {
+            return {
+                isComputed: false,
+                confidence: "high",
+                reason: "HTTP error response",
+            };
+        }
+        // Parse math expression
+        const match = payload.match(SIMPLE_MATH_PATTERN);
+        if (!match) {
+            return {
+                isComputed: false,
+                confidence: "high",
+                reason: "Not a math expression",
+            };
+        }
+        try {
+            const result = this.computeExpression(match);
+            if (result === null) {
+                return {
+                    isComputed: false,
+                    confidence: "high",
+                    reason: "Invalid operator",
+                };
+            }
+            const resultStr = result.toString();
+            const hasComputedResult = responseText.includes(resultStr);
+            const normalizedPayload = payload.replace(/\s+/g, "");
+            const hasOriginalExpression = responseText.includes(payload) ||
+                responseText.includes(normalizedPayload);
+            // Basic detection: result present without original expression
+            const basicDetection = hasComputedResult && !hasOriginalExpression;
+            if (!basicDetection) {
+                return {
+                    isComputed: false,
+                    confidence: "high",
+                    reason: "No computed result found",
+                };
+            }
+            // Layer 1: Check if numeric appears in structured data context (Issue #58)
+            if (this.isCoincidentalNumericInStructuredData(result, responseText)) {
+                return {
+                    isComputed: false,
+                    confidence: "low",
+                    reason: "Numeric value appears in structured data field (e.g., count, records)",
+                };
+            }
+            // Layer 2: Tool classification heuristics (Issue #58)
+            if (tool) {
+                const classifier = new ToolClassifier();
+                const classification = classifier.classify(tool.name, tool.description);
+                // Check for read-only/data fetcher categories
+                if (classification.categories.includes(ToolCategory.DATA_FETCHER) ||
+                    classification.categories.includes(ToolCategory.API_WRAPPER) ||
+                    classification.categories.includes(ToolCategory.SEARCH_RETRIEVAL)) {
+                    return {
+                        isComputed: false,
+                        confidence: "low",
+                        reason: `Tool classified as ${classification.categories[0]} - unlikely to compute math`,
+                    };
+                }
+                // Check for "get_", "list_", "fetch_" patterns in tool name
+                if (READ_ONLY_TOOL_NAME_PATTERN.test(tool.name)) {
+                    return {
+                        isComputed: false,
+                        confidence: "low",
+                        reason: "Tool name indicates read-only operation",
+                    };
+                }
+            }
+            // Layer 3: Check for computational language in response
+            const hasComputationalContext = matchesAny(COMPUTATIONAL_INDICATORS, responseText);
+            if (hasComputationalContext) {
+                return {
+                    isComputed: true,
+                    confidence: "high",
+                    reason: "Response contains computational language",
+                };
+            }
+            // Layer 4: Longer responses without computational language are likely data
+            if (responseText.length > 50) {
+                return {
+                    isComputed: false,
+                    confidence: "medium",
+                    reason: "Response lacks computational language, likely coincidental data",
+                };
+            }
+            // Short response with just the number - this is suspicious
+            if (responseText.trim() === resultStr) {
+                return {
+                    isComputed: true,
+                    confidence: "high",
+                    reason: "Response is exactly the computed result",
+                };
+            }
+            // Default: medium confidence (excluded per user decision)
+            return {
+                isComputed: false,
+                confidence: "medium",
+                reason: "Ambiguous - numeric match without computational context",
+            };
+        }
+        catch {
+            return { isComputed: false, confidence: "high", reason: "Parse error" };
+        }
+    }
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use analyzeComputedMathResult instead
+     */
+    isComputedMathResult(payload, responseText) {
+        const analysis = this.analyzeComputedMathResult(payload, responseText);
+        return analysis.isComputed && analysis.confidence === "high";
+    }
+    /**
+     * Check if numeric value appears in structured data context (not as computation result)
+     * Distinguishes {"records": 4} from computed "4" (Issue #58)
+     *
+     * @param result The computed numeric result to check for
+     * @param responseText The response text to analyze
+     * @returns true if the number appears to be coincidental data, not a computed result
+     */
+    isCoincidentalNumericInStructuredData(result, responseText) {
+        // Try to parse as JSON
+        try {
+            const parsed = JSON.parse(responseText);
+            return this.checkObjectForCoincidentalNumeric(parsed, result);
+        }
+        catch {
+            // Not JSON - check for structured text patterns
+            return this.checkTextForCoincidentalNumeric(result, responseText);
+        }
+    }
+    /**
+     * Recursively check JSON object for coincidental numeric values
+     */
+    checkObjectForCoincidentalNumeric(obj, result, depth = 0) {
+        if (depth > 5)
+            return false; // Prevent deep recursion
+        if (typeof obj !== "object" || obj === null)
+            return false;
+        for (const [key, value] of Object.entries(obj)) {
+            // Check if numeric value matches result and key is a data field
+            if (value === result) {
+                const keyLower = key.toLowerCase();
+                if (STRUCTURED_DATA_FIELD_NAMES.some((pattern) => keyLower.includes(pattern))) {
+                    return true;
+                }
+            }
+            // Recurse into nested objects
+            if (typeof value === "object" && value !== null) {
+                if (this.checkObjectForCoincidentalNumeric(value, result, depth + 1)) {
+                    return true;
+                }
+            }
+            // Check arrays
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (typeof item === "object" &&
+                        this.checkObjectForCoincidentalNumeric(item, result, depth + 1)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check text for structured patterns containing coincidental numerics
+     */
+    checkTextForCoincidentalNumeric(result, responseText) {
+        const structuredPatterns = [
+            new RegExp(`(records|count|total|page|items|results|employees|entries|rows)[:\\s]+${result}\\b`, "i"),
+            new RegExp(`\\b${result}\\s+(records|items|results|entries|employees|rows)\\b`, "i"),
+            new RegExp(`page\\s+\\d+\\s+of\\s+${result}\\b`, "i"),
+            new RegExp(`total[:\\s]+${result}\\b`, "i"),
+            new RegExp(`found\\s+${result}\\s+(results|items|entries)`, "i"),
+        ];
+        return structuredPatterns.some((pattern) => pattern.test(responseText));
+    }
+    /**
+     * Compute math expression from regex match
+     * Returns null if invalid operator
+     */
+    computeExpression(match) {
+        const num1 = parseInt(match[1], 10);
+        const op1 = match[2];
+        const num2 = parseInt(match[3], 10);
+        const op2 = match[4];
+        const num3 = match[5] ? parseInt(match[5], 10) : undefined;
+        let result;
+        switch (op1) {
+            case "+":
+                result = num1 + num2;
+                break;
+            case "-":
+                result = num1 - num2;
+                break;
+            case "*":
+                result = num1 * num2;
+                break;
+            case "/":
+                result = Math.floor(num1 / num2);
+                break;
+            default:
+                return null;
+        }
+        if (op2 && num3 !== undefined) {
+            switch (op2) {
+                case "+":
+                    result = result + num3;
+                    break;
+                case "-":
+                    result = result - num3;
+                    break;
+                case "*":
+                    result = result * num3;
+                    break;
+                case "/":
+                    result = Math.floor(result / num3);
+                    break;
+                default:
+                    return null;
+            }
+        }
+        return result;
+    }
+}

package/lib/services/assessment/modules/securityTests/SafeResponseDetector.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Safe Response Detector
+ * Detects safe (non-vulnerable) response patterns
+ *
+ * Extracted from SecurityResponseAnalyzer.ts (Issue #53)
+ * Handles: MCP validation, HTTP errors, reflection detection, validation rejection
+ */
+import { CompatibilityCallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Error info extracted from response
+ */
+export interface ErrorInfo {
+    code?: string | number;
+    message?: string;
+}
+/**
+ * Result of safe response check
+ */
+export interface SafeResponseResult {
+    isSafe: boolean;
+    reason?: string;
+}
+/**
+ * Detects safe response patterns indicating proper tool behavior
+ */
+export declare class SafeResponseDetector {
+    private executionDetector;
+    constructor();
+    /**
+     * Check if response is an MCP validation error (safe rejection)
+     */
+    isMCPValidationError(errorInfo: ErrorInfo, responseText: string): boolean;
+    /**
+     * Check if response is an HTTP error (Issue #26)
+     */
+    isHttpErrorResponse(responseText: string): boolean;
+    /**
+     * Check if response is just reflection (safe)
+     * Two-layer defense: Match reflection patterns, verify NO execution evidence
+     */
+    isReflectionResponse(responseText: string): boolean;
+    /**
+     * Check if response is returning search results
+     */
+    isSearchResultResponse(responseText: string): boolean;
+    /**
+     * Check if response is from a creation/modification operation
+     */
+    isCreationResponse(responseText: string): boolean;
+    /**
+     * Check if tool explicitly rejected input with validation error (SAFE)
+     */
+    isValidationRejection(response: CompatibilityCallToolResult): boolean;
+    /**
+     * Extract response content from MCP response
+     */
+    extractResponseContent(response: CompatibilityCallToolResult): string;
+}
+//# sourceMappingURL=SafeResponseDetector.d.ts.map

package/lib/services/assessment/modules/securityTests/SafeResponseDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SafeResponseDetector.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/securityTests/SafeResponseDetector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAcjF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,iBAAiB,CAA4B;;IAMrD;;OAEG;IACH,oBAAoB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAQzE;;OAEG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAIlD;;;OAGG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAkEnD;;OAEG;IACH,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAIrD;;OAEG;IACH,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAIjD;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO;IA0CrE;;OAEG;IACH,sBAAsB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,MAAM;CAUtE"}

package/lib/services/assessment/modules/securityTests/SafeResponseDetector.js

@@ -0,0 +1,151 @@
+/**
+ * Safe Response Detector
+ * Detects safe (non-vulnerable) response patterns
+ *
+ * Extracted from SecurityResponseAnalyzer.ts (Issue #53)
+ * Handles: MCP validation, HTTP errors, reflection detection, validation rejection
+ */
+import { VALIDATION_ERROR_PATTERNS, STATUS_PATTERNS, REFLECTION_PATTERNS, SEARCH_RESULT_PATTERNS, CREATION_PATTERNS, TEXT_REJECTION_PATTERNS, RESULT_REJECTION_PATTERNS, isHttpError, matchesAny, } from "./SecurityPatternLibrary.js";
+import { ExecutionArtifactDetector } from "./ExecutionArtifactDetector.js";
+/**
+ * Detects safe response patterns indicating proper tool behavior
+ */
+export class SafeResponseDetector {
+    executionDetector;
+    constructor() {
+        this.executionDetector = new ExecutionArtifactDetector();
+    }
+    /**
+     * Check if response is an MCP validation error (safe rejection)
+     */
+    isMCPValidationError(errorInfo, responseText) {
+        if (errorInfo.code === -32602 || errorInfo.code === "-32602") {
+            return true;
+        }
+        return matchesAny(VALIDATION_ERROR_PATTERNS, responseText);
+    }
+    /**
+     * Check if response is an HTTP error (Issue #26)
+     */
+    isHttpErrorResponse(responseText) {
+        return isHttpError(responseText);
+    }
+    /**
+     * Check if response is just reflection (safe)
+     * Two-layer defense: Match reflection patterns, verify NO execution evidence
+     */
+    isReflectionResponse(responseText) {
+        // Combine status patterns and reflection patterns
+        const allReflectionPatterns = [...STATUS_PATTERNS, ...REFLECTION_PATTERNS];
+        const hasReflection = matchesAny(allReflectionPatterns, responseText);
+        if (hasReflection) {
+            try {
+                const parsed = JSON.parse(responseText);
+                const resultText = String(parsed.result || "");
+                const outputFields = [
+                    parsed.stdout,
+                    parsed.stderr,
+                    parsed.output,
+                    parsed.contents,
+                    parsed.execution_log,
+                    parsed.command_output,
+                ]
+                    .filter(Boolean)
+                    .join(" ");
+                const resultIsStatusOnly = matchesAny(STATUS_PATTERNS, resultText);
+                const hasExecutionInOutput = resultIsStatusOnly
+                    ? this.executionDetector.detectExecutionArtifacts(outputFields)
+                    : this.executionDetector.detectExecutionArtifacts(resultText) ||
+                        this.executionDetector.detectExecutionArtifacts(outputFields);
+                if (hasExecutionInOutput) {
+                    return false;
+                }
+                return true;
+            }
+            catch {
+                const hasExecution = this.executionDetector.detectExecutionArtifacts(responseText);
+                if (hasExecution) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        // Check for JSON status patterns
+        try {
+            const parsed = JSON.parse(responseText);
+            if (parsed.action === "test" || parsed.action === "placeholder") {
+                const resultText = String(parsed.result || "");
+                if (!this.executionDetector.detectExecutionArtifacts(resultText)) {
+                    return true;
+                }
+            }
+            if (parsed.status && /(completed|success|ok|done)/.test(parsed.status)) {
+                if (!this.executionDetector.detectExecutionArtifacts(responseText)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // Not JSON
+        }
+        return false;
+    }
+    /**
+     * Check if response is returning search results
+     */
+    isSearchResultResponse(responseText) {
+        return matchesAny(SEARCH_RESULT_PATTERNS, responseText);
+    }
+    /**
+     * Check if response is from a creation/modification operation
+     */
+    isCreationResponse(responseText) {
+        return matchesAny(CREATION_PATTERNS, responseText);
+    }
+    /**
+     * Check if tool explicitly rejected input with validation error (SAFE)
+     */
+    isValidationRejection(response) {
+        const responseText = this.extractResponseContent(response);
+        try {
+            const parsed = JSON.parse(responseText);
+            if (parsed.valid === false ||
+                parsed.error === true ||
+                parsed.error === "true" ||
+                (parsed.error && parsed.error !== false) ||
+                parsed.status === "rejected" ||
+                parsed.status === "invalid" ||
+                parsed.status === "failed") {
+                return true;
+            }
+            if (parsed.errors &&
+                Array.isArray(parsed.errors) &&
+                parsed.errors.length > 0) {
+                return true;
+            }
+            if (parsed.error && typeof parsed.error === "string") {
+                return true;
+            }
+            if (typeof parsed.result === "string") {
+                if (matchesAny(RESULT_REJECTION_PATTERNS, parsed.result)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // Not JSON, check text patterns
+        }
+        return matchesAny(TEXT_REJECTION_PATTERNS, responseText);
+    }
+    /**
+     * Extract response content from MCP response
+     */
+    extractResponseContent(response) {
+        if (response.content && Array.isArray(response.content)) {
+            return response.content
+                .map((c) => c.type === "text" ? c.text : "")
+                .join(" ");
+        }
+        return String(response.content || "");
+    }
+}