@bryan-thompson/inspector-assessment 1.6.0 → 1.7.0

package/client/lib/services/assessment/ToolClassifier.js

@@ -0,0 +1,349 @@
+/**
+ * Tool Classifier
+ * Categorizes MCP tools based on name/description to select appropriate security test patterns
+ *
+ * Validated against broken-mcp server with 16 tools (6 HIGH, 4 MEDIUM, 6 SAFE)
+ */
+export var ToolCategory;
+(function (ToolCategory) {
+    ToolCategory["CALCULATOR"] = "calculator";
+    ToolCategory["SYSTEM_EXEC"] = "system_exec";
+    ToolCategory["DATA_ACCESS"] = "data_access";
+    ToolCategory["TOOL_OVERRIDE"] = "tool_override";
+    ToolCategory["CONFIG_MODIFIER"] = "config_modifier";
+    ToolCategory["URL_FETCHER"] = "fetcher";
+    ToolCategory["UNICODE_PROCESSOR"] = "unicode";
+    ToolCategory["JSON_PARSER"] = "parser";
+    ToolCategory["PACKAGE_INSTALLER"] = "installer";
+    ToolCategory["RUG_PULL"] = "rug_pull";
+    ToolCategory["SAFE_STORAGE"] = "safe_storage";
+    ToolCategory["API_WRAPPER"] = "api_wrapper";
+    ToolCategory["SEARCH_RETRIEVAL"] = "search_retrieval";
+    ToolCategory["CRUD_CREATION"] = "crud_creation";
+    ToolCategory["READ_ONLY_INFO"] = "read_only_info";
+    ToolCategory["GENERIC"] = "generic";
+})(ToolCategory || (ToolCategory = {}));
+/**
+ * Classifies MCP tools into vulnerability categories based on naming patterns
+ * and descriptions. Uses patterns validated by testing against broken-mcp server.
+ */
+export class ToolClassifier {
+    /**
+     * Classify a tool into one or more categories
+     * Returns multiple categories if tool matches multiple patterns
+     */
+    classify(toolName, description) {
+        const categories = [];
+        const confidenceScores = [];
+        const reasons = [];
+        const toolText = `${toolName} ${description || ""}`.toLowerCase();
+        // Calculator tools (HIGH RISK)
+        // Validated: vulnerable_calculator_tool
+        if (this.matchesPattern(toolText, [
+            /calculator/i,
+            /compute/i,
+            /math/i,
+            /calc/i,
+            /eval/i,
+            /arithmetic/i,
+            /expression/i,
+        ])) {
+            categories.push(ToolCategory.CALCULATOR);
+            confidenceScores.push(90);
+            reasons.push("Calculator pattern detected (arithmetic execution risk)");
+        }
+        // System execution tools (HIGH RISK)
+        // Validated: vulnerable_system_exec_tool
+        if (this.matchesPattern(toolText, [
+            /system.*exec/i,
+            /exec.*tool/i,
+            /command/i,
+            /shell/i,
+            /\brun\b/i,
+            /execute/i,
+            /process/i,
+        ])) {
+            categories.push(ToolCategory.SYSTEM_EXEC);
+            confidenceScores.push(95);
+            reasons.push("System execution pattern detected (command injection risk)");
+        }
+        // Data access/leak tools (HIGH RISK)
+        // Validated: vulnerable_data_leak_tool
+        if (this.matchesPattern(toolText, [
+            /leak/i,
+            /\bdata\b/i,
+            /show/i,
+            /\bget\b/i,
+            /\blist\b/i,
+            /display/i,
+            /\benv/i,
+            /secret/i,
+            /\bkey\b/i,
+            /credential/i,
+            /exfiltrat/i,
+        ])) {
+            categories.push(ToolCategory.DATA_ACCESS);
+            confidenceScores.push(85);
+            reasons.push("Data access pattern detected (data exfiltration risk)");
+        }
+        // Tool override/shadowing (HIGH RISK)
+        // Validated: vulnerable_tool_override_tool
+        if (this.matchesPattern(toolText, [
+            /override/i,
+            /shadow/i,
+            /poison/i,
+            /create.*tool/i,
+            /register.*tool/i,
+            /define.*tool/i,
+            /tool.*creator/i,
+            /add.*tool/i,
+        ])) {
+            categories.push(ToolCategory.TOOL_OVERRIDE);
+            confidenceScores.push(92);
+            reasons.push("Tool override pattern detected (shadowing/poisoning risk)");
+        }
+        // Config modification tools (HIGH RISK)
+        // Validated: vulnerable_config_modifier_tool
+        if (this.matchesPattern(toolText, [
+            /config/i,
+            /setting/i,
+            /modifier/i,
+            /\badmin\b/i,
+            /privilege/i,
+            /permission/i,
+            /configure/i,
+            /drift/i,
+        ])) {
+            categories.push(ToolCategory.CONFIG_MODIFIER);
+            confidenceScores.push(88);
+            reasons.push("Config modification pattern detected (configuration drift risk)");
+        }
+        // URL fetching tools (HIGH RISK)
+        // Validated: vulnerable_fetcher_tool
+        if (this.matchesPattern(toolText, [
+            /fetch/i,
+            /\burl\b/i,
+            /http/i,
+            /download/i,
+            /load/i,
+            /retrieve/i,
+            /\bget\b.*url/i,
+            /external/i,
+        ])) {
+            categories.push(ToolCategory.URL_FETCHER);
+            confidenceScores.push(87);
+            reasons.push("URL fetcher pattern detected (indirect prompt injection risk)");
+        }
+        // Unicode processing tools (MEDIUM RISK)
+        // Validated: vulnerable_unicode_processor_tool
+        if (this.matchesPattern(toolText, [
+            /unicode/i,
+            /encode/i,
+            /decode/i,
+            /charset/i,
+            /utf/i,
+            /hex/i,
+            /escape/i,
+        ])) {
+            categories.push(ToolCategory.UNICODE_PROCESSOR);
+            confidenceScores.push(75);
+            reasons.push("Unicode processor pattern detected (bypass encoding risk)");
+        }
+        // JSON/nested parsing tools (MEDIUM RISK)
+        // Validated: vulnerable_nested_parser_tool
+        if (this.matchesPattern(toolText, [
+            /parser/i,
+            /parse/i,
+            /json/i,
+            /xml/i,
+            /yaml/i,
+            /nested/i,
+            /deserialize/i,
+            /unmarshal/i,
+        ])) {
+            categories.push(ToolCategory.JSON_PARSER);
+            confidenceScores.push(78);
+            reasons.push("JSON/nested parser pattern detected (nested injection risk)");
+        }
+        // Package installation tools (MEDIUM RISK)
+        // Validated: vulnerable_package_installer_tool
+        if (this.matchesPattern(toolText, [
+            /install/i,
+            /package/i,
+            /\bnpm\b/i,
+            /\bpip\b/i,
+            /dependency/i,
+            /module/i,
+            /library/i,
+            /\bgem\b/i,
+        ])) {
+            categories.push(ToolCategory.PACKAGE_INSTALLER);
+            confidenceScores.push(70);
+            reasons.push("Package installer pattern detected (typosquatting risk)");
+        }
+        // Rug pull (behavioral change over time) (MEDIUM RISK)
+        // Validated: vulnerable_rug_pull_tool
+        if (this.matchesPattern(toolText, [
+            /rug.*pull/i,
+            /trust/i,
+            /behavior.*change/i,
+            /malicious.*after/i,
+            /invocation.*count/i,
+        ])) {
+            categories.push(ToolCategory.RUG_PULL);
+            confidenceScores.push(80);
+            reasons.push("Rug pull pattern detected (behavioral change risk)");
+        }
+        // API wrapper tools (SAFE - data passing, not code execution)
+        // These tools call external APIs and return data as text, not execute it as code
+        // Examples: Firecrawl (scrape, crawl, search), HTTP clients, REST/GraphQL clients
+        if (this.matchesPattern(toolText, [
+            /firecrawl/i,
+            /\bscrape\b/i,
+            /\bcrawl\b/i,
+            /web.*scraping/i,
+            /api.*wrapper/i,
+            /http.*client/i,
+            /web.*client/i,
+            /rest.*client/i,
+            /graphql.*client/i,
+            /fetch.*web.*content/i,
+        ])) {
+            categories.push(ToolCategory.API_WRAPPER);
+            confidenceScores.push(95);
+            reasons.push("API wrapper pattern detected (safe data passing, not code execution)");
+        }
+        // Search and retrieval tools (SAFE - returns search results/data, not code execution)
+        // Examples: notion-search, notion-query-database, search, find, lookup
+        if (this.matchesPattern(toolText, [
+            /\bsearch\b/i,
+            /\bfind\b/i,
+            /\blookup\b/i,
+            /\bquery\b/i,
+            /retrieve/i,
+            /\blist\b/i,
+            /get.*users/i,
+            /get.*pages/i,
+            /get.*database/i,
+        ])) {
+            categories.push(ToolCategory.SEARCH_RETRIEVAL);
+            confidenceScores.push(93);
+            reasons.push("Search/retrieval pattern detected (returns data, not code execution)");
+        }
+        // CRUD creation/modification tools (SAFE - creates/modifies resources, not code execution)
+        // Examples: notion-create-database, notion-create-page, create, add, insert, update
+        if (this.matchesPattern(toolText, [
+            /\bcreate\b/i,
+            /\badd\b/i,
+            /\binsert\b/i,
+            /\bupdate\b/i,
+            /\bmodify\b/i,
+            /\bdelete\b/i,
+            /\bduplicate\b/i,
+            /\bmove\b/i,
+            /\bappend\b/i,
+        ])) {
+            categories.push(ToolCategory.CRUD_CREATION);
+            confidenceScores.push(92);
+            reasons.push("CRUD operation pattern detected (data manipulation, not code execution)");
+        }
+        // Read-only info tools (SAFE - returns user/workspace info, intended data exposure)
+        // Examples: notion-get-self, notion-get-teams, get-self, whoami, get-info, get-status
+        if (this.matchesPattern(toolText, [
+            /get.*self/i,
+            /get.*teams/i,
+            /get.*info/i,
+            /get.*status/i,
+            /\bwhoami\b/i,
+            /get.*workspace/i,
+            /get.*user/i,
+            /current.*user/i,
+        ])) {
+            categories.push(ToolCategory.READ_ONLY_INFO);
+            confidenceScores.push(94);
+            reasons.push("Read-only info pattern detected (intended data exposure, not vulnerability)");
+        }
+        // Safe storage tools (CONTROL GROUP - should never show vulnerabilities)
+        // Validated: safe_storage_tool_mcp, safe_search_tool_mcp, safe_list_tool_mcp,
+        //            safe_info_tool_mcp, safe_echo_tool_mcp, safe_validate_tool_mcp
+        if (this.matchesPattern(toolText, [
+            /safe.*storage/i,
+            /safe.*search/i,
+            /safe.*list/i,
+            /safe.*info/i,
+            /safe.*echo/i,
+            /safe.*validate/i,
+            /safe.*tool/i,
+        ])) {
+            categories.push(ToolCategory.SAFE_STORAGE);
+            confidenceScores.push(99);
+            reasons.push("Safe tool pattern detected (control group - should be safe)");
+        }
+        // Default to generic if no specific matches
+        if (categories.length === 0) {
+            categories.push(ToolCategory.GENERIC);
+            confidenceScores.push(50);
+            reasons.push("No specific pattern match, using generic tests");
+        }
+        // Calculate overall confidence (average of matched pattern confidences)
+        const avgConfidence = confidenceScores.reduce((a, b) => a + b, 0) / confidenceScores.length;
+        return {
+            toolName,
+            categories,
+            confidence: Math.round(avgConfidence),
+            reasoning: reasons.join("; "),
+        };
+    }
+    /**
+     * Check if text matches any of the provided patterns
+     */
+    matchesPattern(text, patterns) {
+        return patterns.some((pattern) => pattern.test(text));
+    }
+    /**
+     * Get all tool categories (for testing/debugging)
+     */
+    static getAllCategories() {
+        return Object.values(ToolCategory);
+    }
+    /**
+     * Get risk level for a category
+     */
+    static getRiskLevel(category) {
+        const highRiskCategories = [
+            ToolCategory.CALCULATOR,
+            ToolCategory.SYSTEM_EXEC,
+            ToolCategory.DATA_ACCESS,
+            ToolCategory.TOOL_OVERRIDE,
+            ToolCategory.CONFIG_MODIFIER,
+            ToolCategory.URL_FETCHER,
+        ];
+        const mediumRiskCategories = [
+            ToolCategory.UNICODE_PROCESSOR,
+            ToolCategory.JSON_PARSER,
+            ToolCategory.PACKAGE_INSTALLER,
+            ToolCategory.RUG_PULL,
+        ];
+        const lowRiskCategories = [
+            ToolCategory.API_WRAPPER,
+            ToolCategory.SEARCH_RETRIEVAL,
+            ToolCategory.CRUD_CREATION,
+            ToolCategory.READ_ONLY_INFO,
+            ToolCategory.SAFE_STORAGE,
+            ToolCategory.GENERIC,
+        ];
+        if (highRiskCategories.includes(category))
+            return "HIGH";
+        if (mediumRiskCategories.includes(category))
+            return "MEDIUM";
+        if (lowRiskCategories.includes(category))
+            return "LOW";
+        return "LOW";
+    }
+    /**
+     * Classify multiple tools at once
+     */
+    classifyBatch(tools) {
+        return tools.map((tool) => this.classify(tool.name, tool.description));
+    }
+}

package/client/lib/services/assessment/lib/claudeCodeBridge.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Claude Code Bridge
+ *
+ * Provides integration with Claude Code CLI for intelligent analysis tasks.
+ * Uses shell execution with `claude --print` for stateless reasoning.
+ *
+ * This bridge enables:
+ * - Intelligent test parameter generation
+ * - Semantic AUP violation analysis
+ * - Tool behavior inference for annotation validation
+ * - Documentation quality assessment
+ */
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { AUPCategory } from "../../../lib/assessmentTypes.js";
+/**
+ * Response from Claude Code execution
+ */
+export interface ClaudeCodeResponse {
+    success: boolean;
+    output: string;
+    error?: string;
+    executionTimeMs?: number;
+}
+/**
+ * Configuration for Claude Code Bridge
+ */
+export interface ClaudeCodeBridgeConfig {
+    enabled: boolean;
+    timeout?: number;
+    maxRetries?: number;
+    features: {
+        intelligentTestGeneration?: boolean;
+        aupSemanticAnalysis?: boolean;
+        behaviorInference?: boolean;
+        annotationInference?: boolean;
+        documentationAssessment?: boolean;
+        documentationQuality?: boolean;
+    };
+}
+/**
+ * Context for AUP violation analysis
+ */
+export interface AUPViolationContext {
+    toolName: string;
+    toolDescription: string;
+    category: AUPCategory;
+    categoryName: string;
+    location: string;
+}
+/**
+ * Result of AUP semantic analysis
+ */
+export interface AUPSemanticAnalysisResult {
+    isViolation: boolean;
+    isConfirmedViolation: boolean;
+    confidence: number;
+    reasoning: string;
+    category: AUPCategory;
+    suggestedAction: "block" | "flag_for_review" | "allow";
+    contextFactors: string[];
+}
+/**
+ * Result of tool behavior inference
+ */
+export interface BehaviorInferenceResult {
+    expectedReadOnly: boolean;
+    expectedDestructive: boolean;
+    confidence: number;
+    reasoning: string;
+    suggestedAnnotations: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+    };
+    misalignmentDetected: boolean;
+    misalignmentDetails?: string;
+}
+/**
+ * Result of intelligent test generation
+ */
+export interface TestGenerationResult {
+    scenarios: Array<{
+        name: string;
+        description: string;
+        params: Record<string, unknown>;
+        expectedBehavior: string;
+        category: "happy_path" | "edge_case" | "boundary" | "error_case";
+    }>;
+    reasoning: string;
+}
+/**
+ * Default configuration with minimal features
+ */
+export declare const DEFAULT_CLAUDE_CODE_CONFIG: ClaudeCodeBridgeConfig;
+/**
+ * Full configuration with all features enabled
+ */
+export declare const FULL_CLAUDE_CODE_CONFIG: ClaudeCodeBridgeConfig;
+/**
+ * Claude Code Bridge
+ * Executes Claude CLI for intelligent analysis during MCP assessments
+ */
+export declare class ClaudeCodeBridge {
+    private config;
+    private isAvailable;
+    constructor(config: ClaudeCodeBridgeConfig);
+    /**
+     * Check if a specific feature is enabled
+     * Note: annotationInference is an alias for behaviorInference
+     */
+    isFeatureEnabled(feature: keyof ClaudeCodeBridgeConfig["features"]): boolean;
+    /**
+     * Check if Claude CLI is available on the system
+     */
+    private checkClaudeAvailability;
+    /**
+     * Execute Claude CLI with a prompt
+     */
+    private executeClaudeCommand;
+    /**
+     * Execute with retries
+     */
+    private executeWithRetry;
+    /**
+     * Parse JSON from Claude response, handling markdown code blocks
+     */
+    private parseJsonResponse;
+    /**
+     * Analyze an AUP violation for false positives using semantic analysis
+     * @param matchedText - The text that matched the AUP pattern
+     * @param context - Context about the violation
+     */
+    analyzeAUPViolation(matchedText: string, context: AUPViolationContext): Promise<AUPSemanticAnalysisResult | null>;
+    /**
+     * Infer expected tool behavior for annotation validation
+     */
+    inferToolBehavior(tool: Tool, currentAnnotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+    }): Promise<BehaviorInferenceResult | null>;
+    /**
+     * Generate intelligent test scenarios for a tool
+     */
+    generateTestScenarios(tool: Tool, existingScenarios: number): Promise<TestGenerationResult | null>;
+    /**
+     * Generate test parameters for a tool
+     * This returns just the parameter sets, used by TestDataGenerator
+     */
+    generateTestParameters(tool: Tool): Promise<Record<string, unknown>[] | null>;
+    /**
+     * Assess documentation quality
+     */
+    assessDocumentation(readmeContent: string, toolCount: number): Promise<{
+        score: number;
+        issues: string[];
+        suggestions: string[];
+    } | null>;
+}
+//# sourceMappingURL=claudeCodeBridge.d.ts.map

package/client/lib/services/assessment/lib/claudeCodeBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeBridge.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/lib/claudeCodeBridge.ts"],"names":[],"mappings":"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"}