mcpsec 2.7.2__tar.gz → 2.7.3__tar.gz

{mcpsec-2.7.2 → mcpsec-2.7.3}/CHANGELOG.md

@@ -5,20 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.7.2] - 2026-07-12
 
-### Changed
-- **Codebase Cleanup & Deduplication**: Removed 156 duplicate regexes and consolidated 3,459 sink patterns into 9 organized files by vulnerability type.
-- **Generator Consolidation**: Merged protocol_state generators and renamed memory_exhaustion_v2 for better maintainability.
-- **Dead Code Removal**: Removed unused AI analyzer stubs (	aint_analyzer, py_analyzer) and SQL exploiter stubs.
-- **Test Organization**: Moved test server fixtures from 	ests/ to 	ests/servers/ for cleaner separation of tests and fixtures.
+## [2.7.3] - 2026-11-01
 
-### Fixed
-- **Silent Exception Handling**: Replaced bare except: pass blocks across 130+ files with proper logger.debug statements.
-- **Unicode Errors on Windows**: Fixed UnicodeEncodeError crashes caused by rich console emojis by forcing UTF-8 stdout encoding.
-- **Unused Imports**: Cleaned up stale imports in cli.py.
+### Added
+- **Schema-Aware Argument Fuzzer (schema_fuzzer)**: Per-parameter, type-targeted mutation fuzzing driven by tool inputSchema.
+  - Type-targeted mutation catalog for strings (path traversal, command injection, template injection, SSRF, length abuse, unicode, format and pattern violations), numbers and integers (numeric boundaries, floats, NaN/Infinity tokens, min/max bounds), booleans (type confusion), arrays (item recursion, min/max bounds, deep nesting), and objects (prototype pollution, unexpected keys, deep nesting).
+  - Out-of-enum value generation for enum properties.
+  - Baseline value generation for non-targeted required parameters to ensure valid payloads reach tool handlers instead of failing schema validation.
+  - Schema-less tool support (defaults to untyped string argument fuzzing).
+  - Configurable intensity scaling (low, medium, high, insane).
+  - Comprehensive unit test suite in 	ests/test_schema_fuzzer.py.
 
+### Improved
+- **Fuzz Engine Wiring**: Automatically discovers server tools on startup and executes targeted schema fuzzing.
+- Replaced naive single-value spray in uzz_engine.py with schema-aware parameter targeting and baseline parameter population.
+
+## [2.7.2] - 2026-07-28
 
+### Added
+- Support for MCP 2026-07-28 stateless protocol lifecycle (server/discover).
 ## [2.7.1] - 2026-04-15
 
 ### Improved
@@ -315,4 +321,4 @@ mcpsec evolve --stdio "server" --corpus ./corpus --crashes ./crashes
 - Protocol fuzzer with 500+ test cases
 - AI-powered payload generation
 - Semgrep-based static analysis
-- Support for OpenAI, Anthropic, Google, Groq, DeepSeek, Ollama
+- Support for OpenAI, Anthropic, Google, Groq, DeepSeek, Ollama

{mcpsec-2.7.2 → mcpsec-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mcpsec
-Version: 2.7.2
+Version: 2.7.3
 Summary: Security scanner for MCP (Model Context Protocol) servers - pentest your AI agent's tool connections
 Project-URL: Homepage, https://github.com/manthanghasadiya/mcpsec
 Project-URL: Documentation, https://github.com/manthanghasadiya/mcpsec#readme

mcpsec-2.7.3/mcpsec/__init__.py

@@ -0,0 +1,3 @@
+"""mcpsec - Security scanner for MCP server implementations."""
+
+__version__ = "2.7.3"

mcpsec-2.7.3/mcpsec/__main__.py

@@ -0,0 +1,4 @@
+from mcpsec.cli import app
+
+if __name__ == "__main__":
+    app()

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/client/mcp_client.py

@@ -14,7 +14,11 @@ from typing import Any
 
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
-from mcp.client.streamable_http import streamablehttp_client
+
+try:
+    from mcp.client.streamable_http import streamable_http_client
+except ImportError:  # mcp < 2.0.0
+    from mcp.client.streamable_http import streamablehttp_client as streamable_http_client
 
 from mcpsec.models import (
     PromptInfo,
@@ -77,21 +81,42 @@ class MCPSecClient:
         self.session = await self._exit_stack.enter_async_context(
             ClientSession(read_stream, write_stream)
         )
-        await self.session.initialize()
+        await self._initialize()
         return await self._enumerate()
 
     async def connect_http(self, url: str, headers: dict | None = None) -> ServerProfile:
         """Connect to an MCP server via streamable HTTP transport."""
-        http_transport = await self._exit_stack.enter_async_context(
-            streamablehttp_client(url=url, headers=headers)
-        )
+        try:
+            from mcp.client.streamable_http import create_mcp_http_client
+
+            http_client = create_mcp_http_client(headers=headers or {})
+        except ImportError:  # mcp < 2.0.0
+            http_client = None
+
+        if http_client is not None:
+            http_transport = await self._exit_stack.enter_async_context(
+                streamable_http_client(url=url, http_client=http_client)
+            )
+        else:
+            http_transport = await self._exit_stack.enter_async_context(
+                streamable_http_client(url=url, headers=headers)
+            )
         read_stream, write_stream = http_transport[0], http_transport[1]
         self.session = await self._exit_stack.enter_async_context(
             ClientSession(read_stream, write_stream)
         )
-        await self.session.initialize()
+        await self._initialize()
         return await self._enumerate()
 
+    async def _initialize(self):
+        """Initialize the session, preferring the stateless server/discover probe."""
+        if not self.session:
+            raise RuntimeError("Not connected")
+        try:
+            await self.session.discover()
+        except Exception:
+            await self.session.initialize()
+
     async def call_tool(
         self, tool_name: str, arguments: dict[str, Any], timeout: float = 30.0
     ) -> Any:
@@ -124,9 +149,12 @@ class MCPSecClient:
             for tool in tools_result.tools:
                 params = {}
                 raw_schema = {}
-                if tool.inputSchema and "properties" in tool.inputSchema:
-                    raw_schema = tool.inputSchema
-                    for param_name, param_def in tool.inputSchema["properties"].items():
+                input_schema = getattr(tool, "inputSchema", None) or getattr(
+                    tool, "input_schema", None
+                )
+                if input_schema and "properties" in input_schema:
+                    raw_schema = input_schema
+                    for param_name, param_def in input_schema["properties"].items():
                         param_type = param_def.get("type", "any")
                         params[param_name] = param_type
 

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/exploit/evidence.py

@@ -89,16 +89,23 @@ def main():
     proc = subprocess.Popen(SERVER_CMD.split(), stdin=subprocess.PIPE,
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
     
-    # Initialize Handshake
-    print("[*] Sending initialization...")
-    send_jsonrpc(proc, {{
-        "jsonrpc": "2.0", "id": 1, "method": "initialize",
-        "params": {{"protocolVersion": "2024-11-05", "capabilities": {{}},
+    # Probe: server/discover (2026-07-28 stateless) with legacy initialize fallback
+    print("[*] Probing server capabilities...")
+    discover = send_jsonrpc(proc, {{
+        "jsonrpc": "2.0", "id": 1, "method": "server/discover",
+        "params": {{"protocolVersion": "2026-07-28", "capabilities": {{}},
                    "clientInfo": {{"name": "mcpsec-poc", "version": "1.0"}}}}
     }})
-    proc.stdin.write(json.dumps({{"jsonrpc":"2.0","method":"notifications/initialized"}}) + "\\n")
-    proc.stdin.flush()
-    time.sleep(0.5)
+    if not discover or "result" not in discover:
+        print("[*] server/discover unsupported, falling back to legacy initialize...")
+        send_jsonrpc(proc, {{
+            "jsonrpc": "2.0", "id": 1, "method": "initialize",
+            "params": {{"protocolVersion": "2024-11-05", "capabilities": {{}},
+                       "clientInfo": {{"name": "mcpsec-poc", "version": "1.0"}}}}
+        }})
+        proc.stdin.write(json.dumps({{"jsonrpc":"2.0","method":"notifications/initialized"}}) + "\\n")
+        proc.stdin.flush()
+        time.sleep(0.5)
     
     # Exploit Request
     print("[*] Sending exploit payload to {tool_name}...")

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/fuzzer/chain/chain_engine.py

@@ -264,18 +264,18 @@ class ChainEngine:
         if hasattr(self._transport, "framing"):
             self._transport.framing = "jsonl"
 
-        init_msg = {
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "initialize",
-            "params": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {},
-                "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
-            },
-        }
-
-        init_response = await self._transport.send_request_async(init_msg)
+        init_response = await self._transport.send_request_async(
+            {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "server/discover",
+                "params": {
+                    "protocolVersion": "2026-07-28",
+                    "capabilities": {},
+                    "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
+                },
+            }
+        )
 
         # If JSONL didn't work, try CRLF framing (Node servers)
         if not init_response or "result" not in init_response:
@@ -295,8 +295,54 @@ class ChainEngine:
 
             if hasattr(self._transport, "framing"):
                 self._transport.framing = "crlf"
+            init_response = await self._transport.send_request_async(
+                {
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "server/discover",
+                    "params": {
+                        "protocolVersion": "2026-07-28",
+                        "capabilities": {},
+                        "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
+                    },
+                }
+            )
+
+        # Legacy fallback: initialize handshake
+        if not init_response or "result" not in init_response:
+            if self.config.verbose:
+                console.print("  [dim]server/discover failed, trying legacy initialize...[/dim]")
+
+            if hasattr(self._transport, "restart_async"):
+                await self._transport.restart_async()
+            else:
+                restart_fn = getattr(self._transport, "restart", None)
+                if restart_fn:
+                    await asyncio.to_thread(restart_fn)
+            await asyncio.sleep(1.0)
+
+            init_msg = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {},
+                    "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
+                },
+            }
             init_response = await self._transport.send_request_async(init_msg)
 
+            if init_response and "result" in init_response:
+                # Send initialized notification (no ID!)
+                await self._transport.send_notification_async(
+                    {
+                        "jsonrpc": "2.0",
+                        "method": "notifications/initialized",
+                    }
+                )
+                await asyncio.sleep(0.5)
+
         if not init_response or "result" not in init_response:
             console.print("[yellow]  Warning: Server did not respond to initialize[/yellow]")
             return
@@ -305,16 +351,6 @@ class ChainEngine:
             framing = getattr(self._transport, "framing", "unknown")
             console.print(f"  [dim]Using framing: {framing}[/dim]")
 
-        # Send initialized notification (no ID!)
-        await self._transport.send_notification_async(
-            {
-                "jsonrpc": "2.0",
-                "method": "notifications/initialized",
-            }
-        )
-
-        await asyncio.sleep(0.5)  # Give server time to process
-
         # Get tools list
         tools_response = await self._transport.send_request_async(
             {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}
@@ -803,25 +839,38 @@ class ChainEngine:
         await self._transport.restart()
         await asyncio.sleep(1.0)
 
-        # Re-initialize
-        await self._transport.send_request_async(
+        # Re-initialize (discover first, legacy fallback)
+        init_response = await self._transport.send_request_async(
             {
                 "jsonrpc": "2.0",
                 "id": 1,
-                "method": "initialize",
+                "method": "server/discover",
                 "params": {
-                    "protocolVersion": "2024-11-05",
+                    "protocolVersion": "2026-07-28",
                     "capabilities": {},
                     "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
                 },
             }
         )
-        await self._transport.send_notification_async(
-            {
-                "jsonrpc": "2.0",
-                "method": "notifications/initialized",
-            }
-        )
+        if not init_response or "result" not in init_response:
+            await self._transport.send_request_async(
+                {
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {},
+                        "clientInfo": {"name": "mcpsec-chained", "version": "1.0.0"},
+                    },
+                }
+            )
+            await self._transport.send_notification_async(
+                {
+                    "jsonrpc": "2.0",
+                    "method": "notifications/initialized",
+                }
+            )
         await asyncio.sleep(0.5)
 
     def _print_dependency_graph(self, graph: dict) -> None:

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/fuzzer/evolve/engine.py

@@ -182,8 +182,8 @@ class EvolveFuzzEngine:
     def _create_default_seeds(self):
         """Create initial seed inputs."""
         seeds = [
-            {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
-                "protocolVersion": "2024-11-05",
+            {"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {
+                "protocolVersion": "2026-07-28",
                 "capabilities": {},
                 "clientInfo": {"name": "mcpsec-evolve", "version": "1.0"}
             }},
@@ -194,6 +194,9 @@ class EvolveFuzzEngine:
             {"jsonrpc": "2.0", "id": 6, "method": "tools/call", "params": {
                 "name": "test", "arguments": {}
             }},
+            {"jsonrpc": "2.0", "id": 7, "method": "tasks/get", "params": {
+                "taskId": "task-1"
+            }},
         ]
 
         for seed in seeds:
@@ -212,7 +215,22 @@ class EvolveFuzzEngine:
         try:
             self.process = await self._start_server()
 
-            # Send initialize
+            # Send server/discover (2026-07-28 stateless), fall back to initialize
+            discover_req = json.dumps({
+                "jsonrpc": "2.0", "id": 1, "method": "server/discover",
+                "params": {
+                    "protocolVersion": "2026-07-28",
+                    "capabilities": {},
+                    "clientInfo": {"name": "mcpsec-evolve", "version": "1.0"}
+                }
+            }).encode() + b"\n"
+
+            self.process.stdin.write(discover_req)
+            self.process.stdin.flush()
+
+            await asyncio.sleep(0.5)
+
+            # Legacy fallback: initialize handshake
             init_req = json.dumps({
                 "jsonrpc": "2.0", "id": 1, "method": "initialize",
                 "params": {

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/fuzzer/evolve/mcp_mutators.py

@@ -69,7 +69,8 @@ class MCPStructureMutator(Mutator):
         """Change the method to something unexpected."""
         methods = [
             "tools/call", "tools/list", "resources/read", "resources/list",
-            "prompts/get", "initialize", "ping", "shutdown",
+            "prompts/get", "initialize", "server/discover", "tasks/get",
+            "tasks/update", "subscriptions/listen", "ping", "shutdown",
             "../../../etc/passwd", "'; DROP TABLE tools;--",
             "AAAA" * 100, "", None, 12345, {"nested": "method"},
             "tools/call\x00hidden", "tools/../../call",

{mcpsec-2.7.2 → mcpsec-2.7.3}/mcpsec/fuzzer/evolve/mutators.py

@@ -213,6 +213,8 @@ class DictionaryMutator(Mutator):
         b'"initialize"', b'"tools/list"', b'"tools/call"',
         b'"resources/read"', b'"resources/list"', b'"prompts/list"',
         b'"notifications/initialized"', b'"ping"',
+        b'"server/discover"', b'"tasks/get"', b'"tasks/update"',
+        b'"subscriptions/listen"', b'"inputResponses"', b'"input_required"',
         b'"protocolVersion"', b'"capabilities"', b'"clientInfo"',
         b'"name"', b'"version"', b'"arguments"',
         b'null', b'true', b'false', b'{}', b'[]',