@bryan-thompson/inspector-assessment-client 1.21.5 → 1.22.1

package/dist/assets/{OAuthCallback-6Ra9gys1.js → OAuthCallback-jmgqk_c8.js}

@@ -1,4 +1,4 @@
-import { u as useToast, r as reactExports, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-Bf4oNKiz.js";
+import { u as useToast, r as reactExports, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-Dln9FIlO.js";
 const OAuthCallback = ({ onConnect }) => {
   const { toast } = useToast();
   const hasProcessedRef = reactExports.useRef(false);

package/dist/assets/{OAuthDebugCallback-B3RgloRQ.js → OAuthDebugCallback-CE7fBC0F.js}

@@ -1,4 +1,4 @@
-import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-Bf4oNKiz.js";
+import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-Dln9FIlO.js";
 const OAuthDebugCallback = ({ onConnect }) => {
   reactExports.useEffect(() => {
     let isProcessed = false;

package/dist/assets/{index-Bf4oNKiz.js → index-Dln9FIlO.js}

@@ -16320,7 +16320,7 @@ object({
   token_type_hint: string().optional()
 }).strip();
 const name = "@bryan-thompson/inspector-assessment-client";
-const version$1 = "1.21.4";
+const version$1 = "1.22.0";
 const packageJson = {
   name,
   version: version$1
@@ -45352,7 +45352,7 @@ const useTheme = () => {
     [theme, setThemeWithSideEffect]
   );
 };
-const version = "1.21.4";
+const version = "1.22.0";
 var [createTooltipContext] = createContextScope("Tooltip", [
   createPopperScope
 ]);
@@ -53359,6 +53359,12 @@ class SecurityAssessor extends BaseAssessor {
         evidence: "Tool safely reflected input without execution"
       };
     }
+    if (this.isComputedMathResult(payload.payload, responseText)) {
+      return {
+        isVulnerable: true,
+        evidence: `Tool computed math expression result instead of storing/echoing it (payload: ${payload.payload})`
+      };
+    }
     if (this.isValidationRejection(response)) {
       return {
         isVulnerable: false,
@@ -53537,6 +53543,72 @@ class SecurityAssessor extends BaseAssessor {
     ];
     return executionIndicators.some((pattern2) => pattern2.test(responseText));
   }
+  /**
+   * Check if a math expression payload was computed (execution evidence)
+   * Returns true if the response contains the computed result but NOT the original expression.
+   *
+   * This is key evidence of execution:
+   * - VULNERABLE: payload "15*37+100" → response contains "655" (computed result)
+   * - SAFE: payload "15*37+100" → response contains "15*37+100" (echoed, not computed)
+   *
+   * Added for Issue #14: False positives on safe input reflection
+   */
+  isComputedMathResult(payload, responseText) {
+    const simpleMathPattern = /^\s*(\d+)\s*([+\-*\/])\s*(\d+)(?:\s*([+\-*\/])\s*(\d+))?\s*$/;
+    const match = payload.match(simpleMathPattern);
+    if (!match) {
+      return false;
+    }
+    try {
+      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) : void 0;
+      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 false;
+      }
+      if (op2 && num3 !== void 0) {
+        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 false;
+        }
+      }
+      const resultStr = result.toString();
+      const hasComputedResult = responseText.includes(resultStr);
+      const normalizedPayload = payload.replace(/\s+/g, "");
+      const hasOriginalExpression = responseText.includes(payload) || responseText.includes(normalizedPayload);
+      return hasComputedResult && !hasOriginalExpression;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Perform additional security checks
    */
@@ -53841,7 +53913,27 @@ class SecurityAssessor extends BaseAssessor {
       /data.?stored.?safely/i,
       /without.?deserialization/i,
       /no.?pickle/i,
-      /stored.?without.?deserializ/i
+      /stored.?without.?deserializ/i,
+      // NEW: Hash-based sanitization patterns (Issue #14 fix)
+      // These indicate the tool replaced dangerous input with safe hash identifiers
+      /\[ref-[a-f0-9]+\]/i,
+      // Hash-based sanitization: [ref-a1b2c3d4]
+      /stored.*\[ref-/i,
+      // "Expression stored: [ref-...]"
+      /\[sanitized\]/i,
+      // [sanitized] placeholder
+      /\[redacted\]/i,
+      // [redacted] placeholder
+      /\[filtered\]/i,
+      // [filtered] placeholder
+      /\[blocked\]/i,
+      // [blocked] placeholder
+      /expression.*stored:/i,
+      // "Expression stored:" prefix
+      /input.*sanitized/i,
+      // "Input sanitized"
+      /content.*replaced/i
+      // "Content replaced with hash"
     ];
     const hasReflection = reflectionPatterns.some(
       (pattern2) => pattern2.test(responseText)
@@ -59174,13 +59266,13 @@ const App = () => {
   ) });
   if (window.location.pathname === "/oauth/callback") {
     const OAuthCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthCallback-6Ra9gys1.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthCallback-jmgqk_c8.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthCallback, { onConnect: onOAuthConnect }) });
   }
   if (window.location.pathname === "/oauth/callback/debug") {
     const OAuthDebugCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthDebugCallback-B3RgloRQ.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthDebugCallback-CE7fBC0F.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthDebugCallback, { onConnect: onOAuthDebugConnect }) });
   }

package/dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/mcp.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCP Inspector</title>
-    <script type="module" crossorigin src="/assets/index-Bf4oNKiz.js"></script>
+    <script type="module" crossorigin src="/assets/index-Dln9FIlO.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DiyPO_Zj.css">
   </head>
   <body>

package/lib/services/assessment/modules/SecurityAssessor.d.ts

@@ -102,6 +102,17 @@ export declare class SecurityAssessor extends BaseAssessor {
      * - VULNERABLE: "SQL executed: syntax error" (error DURING execution)
      */
     private hasExecutionEvidence;
+    /**
+     * Check if a math expression payload was computed (execution evidence)
+     * Returns true if the response contains the computed result but NOT the original expression.
+     *
+     * This is key evidence of execution:
+     * - VULNERABLE: payload "15*37+100" → response contains "655" (computed result)
+     * - SAFE: payload "15*37+100" → response contains "15*37+100" (echoed, not computed)
+     *
+     * Added for Issue #14: False positives on safe input reflection
+     */
+    private isComputedMathResult;
     /**
      * Perform additional security checks
      */

package/lib/services/assessment/modules/SecurityAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAc9D,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,iBAAiB,CAAuC;IAC1D,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuFrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;;;OAIG;YACW,yBAAyB;IAuKvC;;;;OAIG;YACW,qBAAqB;IA4JnC;;OAEG;YACW,WAAW;IA2HzB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAiDtC;;OAEG;IACH,OAAO,CAAC,aAAa;IA+BrB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;OAGG;IACH,OAAO,CAAC,eAAe;IA6HvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAiE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAkC5B;;OAEG;YACW,+BAA+B;IAiC7C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAuI3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IAwM5B;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB;IAwDhC;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAuBtC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,oBAAoB;IAoH5B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAmB3B"}
+{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAc9D,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,iBAAiB,CAAuC;IAC1D,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuFrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;;;OAIG;YACW,yBAAyB;IAuKvC;;;;OAIG;YACW,qBAAqB;IA4JnC;;OAEG;YACW,WAAW;IA2HzB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAiDtC;;OAEG;IACH,OAAO,CAAC,aAAa;IA+BrB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuIvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAiE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAkC5B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IA6E5B;;OAEG;YACW,+BAA+B;IAiC7C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAuI3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IAoN5B;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB;IAwDhC;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAuBtC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,oBAAoB;IAoH5B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAmB3B"}

package/lib/services/assessment/modules/SecurityAssessor.js

@@ -646,6 +646,15 @@ export class SecurityAssessor extends BaseAssessor {
         }
         // Response doesn't match reflection patterns - continue checking
         // Falls through - might be execution (with or without echo of input)
+        // ✅ STEP 1.7: Check for computed math results (Issue #14 fix)
+        // If payload is a math expression and response contains the computed result
+        // (but NOT the original expression), that's evidence of execution
+        if (this.isComputedMathResult(payload.payload, responseText)) {
+            return {
+                isVulnerable: true,
+                evidence: `Tool computed math expression result instead of storing/echoing it (payload: ${payload.payload})`,
+            };
+        }
         // ✅ STEP 2: Check if tool explicitly rejected the input (SAFE)
         // CRITICAL: Check this BEFORE evidence matching to prevent false positives
         // Tools that reject invalid input are secure, regardless of error message content
@@ -849,6 +858,84 @@ export class SecurityAssessor extends BaseAssessor {
         ];
         return executionIndicators.some((pattern) => pattern.test(responseText));
     }
+    /**
+     * Check if a math expression payload was computed (execution evidence)
+     * Returns true if the response contains the computed result but NOT the original expression.
+     *
+     * This is key evidence of execution:
+     * - VULNERABLE: payload "15*37+100" → response contains "655" (computed result)
+     * - SAFE: payload "15*37+100" → response contains "15*37+100" (echoed, not computed)
+     *
+     * Added for Issue #14: False positives on safe input reflection
+     */
+    isComputedMathResult(payload, responseText) {
+        // Check if payload looks like a simple math expression
+        // Matches: "2+2", "15*37+100", "10/2", "5-3", etc.
+        const simpleMathPattern = /^\s*(\d+)\s*([+\-*\/])\s*(\d+)(?:\s*([+\-*\/])\s*(\d+))?\s*$/;
+        const match = payload.match(simpleMathPattern);
+        if (!match) {
+            return false; // Not a simple math expression
+        }
+        // Try to safely evaluate the expression
+        try {
+            // Parse numbers and operators manually (avoid eval)
+            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;
+            // Calculate first operation
+            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 false;
+            }
+            // Calculate second operation if present (left-to-right, no precedence)
+            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 false;
+                }
+            }
+            // Check if response contains the computed result
+            const resultStr = result.toString();
+            const hasComputedResult = responseText.includes(resultStr);
+            // Check if response also contains the original expression (reflection)
+            const normalizedPayload = payload.replace(/\s+/g, "");
+            const hasOriginalExpression = responseText.includes(payload) ||
+                responseText.includes(normalizedPayload);
+            // Vulnerable if: has computed result AND does NOT have original expression
+            // This means the tool executed the expression instead of just echoing it
+            return hasComputedResult && !hasOriginalExpression;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Perform additional security checks
      */
@@ -1195,6 +1282,17 @@ export class SecurityAssessor extends BaseAssessor {
             /without.?deserialization/i,
             /no.?pickle/i,
             /stored.?without.?deserializ/i,
+            // NEW: Hash-based sanitization patterns (Issue #14 fix)
+            // These indicate the tool replaced dangerous input with safe hash identifiers
+            /\[ref-[a-f0-9]+\]/i, // Hash-based sanitization: [ref-a1b2c3d4]
+            /stored.*\[ref-/i, // "Expression stored: [ref-...]"
+            /\[sanitized\]/i, // [sanitized] placeholder
+            /\[redacted\]/i, // [redacted] placeholder
+            /\[filtered\]/i, // [filtered] placeholder
+            /\[blocked\]/i, // [blocked] placeholder
+            /expression.*stored:/i, // "Expression stored:" prefix
+            /input.*sanitized/i, // "Input sanitized"
+            /content.*replaced/i, // "Content replaced with hash"
         ];
         // LAYER 1: Check for reflection/status patterns
         const hasReflection = reflectionPatterns.some((pattern) => pattern.test(responseText));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-client",
-  "version": "1.21.5",
+  "version": "1.22.1",
   "description": "Client-side application for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",