@burtthecoder/mcp-shodan 1.0.5 → 1.0.7

package/README.md

@@ -1,13 +1,14 @@
 # Shodan MCP Server
 
-A Model Context Protocol (MCP) server for querying the [Shodan API](https://shodan.io). This server provides tools for IP lookups, device searches, DNS lookups, vulnerability queries, and more. It is designed to integrate seamlessly with MCP-compatible applications like [Claude Desktop](https://claude.ai).
+A Model Context Protocol (MCP) server for querying the [Shodan API](https://shodan.io) and [Shodan CVEDB](https://cvedb.shodan.io). This server provides tools for IP lookups, device searches, DNS lookups, vulnerability queries, CPE lookups, and more. It is designed to integrate seamlessly with MCP-compatible applications like [Claude Desktop](https://claude.ai).
 
 ## Features
 
 - **IP Lookup**: Retrieve detailed information about an IP address
 - **Search**: Search for devices on Shodan matching specific queries
 - **Ports**: Get a list of ports that Shodan is scanning
-- **Vulnerabilities**: Fetch information about known vulnerabilities (CVE)
+- **Vulnerabilities**: Fetch detailed information about CVEs using Shodan's CVEDB
+- **CPE Lookup**: Search for Common Platform Enumeration (CPE) entries by product name
 - **DNS Lookup**: Resolve hostnames to IP addresses
 
 ## Tools
@@ -27,11 +28,32 @@ A Model Context Protocol (MCP) server for querying the [Shodan API](https://shod
 
 ### 3. Vulnerabilities Tool
 - Name: `vulnerabilities`
-- Description: Fetch information about known vulnerabilities
+- Description: Fetch detailed information about CVEs using Shodan's CVEDB
 - Parameters:
-  * `cve` (required): CVE identifier
-
-### 4. DNS Lookup Tool
+  * `cve` (required): CVE identifier in format CVE-YYYY-NNNNN (e.g., CVE-2021-44228)
+- Returns:
+  * CVE details including:
+    - CVSS v2 and v3 scores
+    - EPSS score and ranking
+    - KEV status
+    - Proposed action
+    - Ransomware campaign information
+    - Affected products (CPEs)
+    - References
+
+### 4. CPE Lookup Tool
+- Name: `cpe_lookup`
+- Description: Search for Common Platform Enumeration (CPE) entries by product name
+- Parameters:
+  * `product` (required): Name of the product to search for
+  * `count` (optional, default: false): If true, returns only the count of matching CPEs
+  * `skip` (optional, default: 0): Number of CPEs to skip (for pagination)
+  * `limit` (optional, default: 1000): Maximum number of CPEs to return
+- Returns:
+  * When count is true: Total number of matching CPEs
+  * When count is false: List of CPEs with pagination details
+
+### 5. DNS Lookup Tool
 - Name: `dns_lookup`
 - Description: Resolve hostnames to IP addresses
 - Parameters:
@@ -91,8 +113,8 @@ There are two ways to configure the Shodan MCP server in Claude Desktop:
 {
   "mcpServers": {
     "shodan-mcp": {
-      "command": "npx",
-      "args": ["@burtthecoder/mcp-shodan"],
+      "command": "npm",
+      "args": ["exec", "@burtthecoder/mcp-shodan"],
       "env": {
         "SHODAN_API_KEY": "your_shodan_api_key",
         "DEBUG": "*"
@@ -102,7 +124,7 @@ There are two ways to configure the Shodan MCP server in Claude Desktop:
 }
 ```
 
-The npx method automatically downloads and runs the latest version of the package from npm.
+The npm exec method automatically downloads and runs the latest version of the package from npm.
 
 Configuration file location:
 
@@ -133,9 +155,12 @@ The server includes comprehensive error handling for:
 - Rate limiting
 - Network errors
 - Invalid input parameters
+- Invalid CVE formats
+- Invalid CPE lookup parameters
 
 ## Version History
 
+- v1.0.6: Added CVEDB integration for enhanced CVE lookups and CPE search functionality
 - v1.0.0: Initial release with core functionality
 
 ## Contributing
@@ -148,4 +173,4 @@ The server includes comprehensive error handling for:
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/build/index.js

@@ -10,13 +10,13 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 dotenv.config();
-// Use os.tmpdir() for the log file to ensure we have write permissions
 const logFilePath = path.join(os.tmpdir(), "mcp-shodan-server.log");
 const SHODAN_API_KEY = process.env.SHODAN_API_KEY;
 if (!SHODAN_API_KEY) {
     throw new Error("SHODAN_API_KEY environment variable is required.");
 }
 const API_BASE_URL = "https://api.shodan.io";
+const CVEDB_API_URL = "https://cvedb.shodan.io";
 // Logging Helper Function
 function logToFile(message) {
     try {
@@ -42,11 +42,19 @@ const SearchArgsSchema = z.object({
         .describe("Maximum results to return."),
 });
 const VulnerabilitiesArgsSchema = z.object({
-    cve: z.string().describe("The CVE identifier to query."),
+    cve: z.string()
+        .regex(/^CVE-\d{4}-\d{4,}$/i, "Must be a valid CVE ID format (e.g., CVE-2021-44228)")
+        .describe("The CVE identifier to query (format: CVE-YYYY-NNNNN)."),
 });
 const DnsLookupArgsSchema = z.object({
     hostnames: z.array(z.string()).describe("List of hostnames to resolve."),
 });
+const CpeLookupArgsSchema = z.object({
+    product: z.string().describe("The name of the product to search for CPEs."),
+    count: z.boolean().optional().default(false).describe("If true, returns only the count of matching CPEs."),
+    skip: z.number().optional().default(0).describe("Number of CPEs to skip (for pagination)."),
+    limit: z.number().optional().default(1000).describe("Maximum number of CPEs to return (max 1000)."),
+});
 // Helper Function to Query Shodan API
 async function queryShodan(endpoint, params) {
     try {
@@ -62,6 +70,37 @@ async function queryShodan(endpoint, params) {
         throw new Error(`Shodan API error: ${errorMessage}`);
     }
 }
+// Helper Function for CVE lookups using CVEDB
+async function queryCVEDB(cveId) {
+    try {
+        logToFile(`Querying CVEDB for: ${cveId}`);
+        const response = await axios.get(`${CVEDB_API_URL}/cve/${cveId}`);
+        return response.data;
+    }
+    catch (error) {
+        if (error.response?.status === 422) {
+            throw new Error(`Invalid CVE ID format: ${cveId}`);
+        }
+        if (error.response?.status === 404) {
+            throw new Error(`CVE not found: ${cveId}`);
+        }
+        throw new Error(`CVEDB API error: ${error.message}`);
+    }
+}
+// Helper Function for CPE lookups using CVEDB
+async function queryCPEDB(params) {
+    try {
+        logToFile(`Querying CVEDB for CPEs with params: ${JSON.stringify(params)}`);
+        const response = await axios.get(`${CVEDB_API_URL}/cpes`, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (error.response?.status === 422) {
+            throw new Error(`Invalid parameters: ${error.response.data?.detail || error.message}`);
+        }
+        throw new Error(`CVEDB API error: ${error.message}`);
+    }
+}
 // Server Setup
 const server = new Server({
     name: "shodan-mcp",
@@ -87,7 +126,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
             name: "shodan-mcp",
             version: "1.0.0",
         },
-        instructions: "This server provides tools for querying Shodan, including IP lookups, searches, and vulnerabilities.",
+        instructions: "This server provides tools for querying Shodan, including IP lookups, searches, vulnerabilities, and CPE lookups.",
     };
 });
 // Register Tools
@@ -105,7 +144,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: "vulnerabilities",
-            description: "Retrieve vulnerability information for a CVE.",
+            description: "Retrieve vulnerability information for a CVE. Use format: CVE-YYYY-NNNNN (e.g., CVE-2021-44228)",
             inputSchema: zodToJsonSchema(VulnerabilitiesArgsSchema),
         },
         {
@@ -113,6 +152,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             description: "Perform DNS lookups using Shodan.",
             inputSchema: zodToJsonSchema(DnsLookupArgsSchema),
         },
+        {
+            name: "cpe_lookup",
+            description: "Search for Common Platform Enumeration (CPE) entries by product name.",
+            inputSchema: zodToJsonSchema(CpeLookupArgsSchema),
+        },
     ];
     logToFile("Registered tools.");
     return { tools };
@@ -159,17 +203,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "vulnerabilities": {
                 const parsedVulnArgs = VulnerabilitiesArgsSchema.safeParse(args);
                 if (!parsedVulnArgs.success) {
-                    throw new Error("Invalid vulnerabilities arguments");
+                    throw new Error("Invalid CVE format. Please use format: CVE-YYYY-NNNNN (e.g., CVE-2021-44228)");
+                }
+                const cveId = parsedVulnArgs.data.cve.toUpperCase();
+                logToFile(`Looking up CVE: ${cveId}`);
+                try {
+                    const result = await queryCVEDB(cveId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    cve_id: result.cve_id,
+                                    summary: result.summary,
+                                    cvss_v3: result.cvss_v3,
+                                    cvss_v2: result.cvss_v2,
+                                    epss: result.epss,
+                                    ranking_epss: result.ranking_epss,
+                                    kev: result.kev,
+                                    propose_action: result.propose_action,
+                                    ransomware_campaign: result.ransomware_campaign,
+                                    published: result.published_time,
+                                    references: result.references,
+                                    affected_products: result.cpes
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: error.message,
+                            },
+                        ],
+                        isError: true,
+                    };
                 }
-                const result = await queryShodan(`/shodan/cve/${parsedVulnArgs.data.cve}`, {});
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
             }
             case "dns_lookup": {
                 const parsedDnsArgs = DnsLookupArgsSchema.safeParse(args);
@@ -194,6 +266,48 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "cpe_lookup": {
+                const parsedCpeArgs = CpeLookupArgsSchema.safeParse(args);
+                if (!parsedCpeArgs.success) {
+                    throw new Error("Invalid cpe_lookup arguments");
+                }
+                try {
+                    const result = await queryCPEDB({
+                        product: parsedCpeArgs.data.product,
+                        count: parsedCpeArgs.data.count,
+                        skip: parsedCpeArgs.data.skip,
+                        limit: parsedCpeArgs.data.limit
+                    });
+                    // Format the response based on whether it's a count request or full CPE list
+                    const formattedResult = parsedCpeArgs.data.count
+                        ? { total_cpes: result.total }
+                        : {
+                            cpes: result.cpes,
+                            skip: parsedCpeArgs.data.skip,
+                            limit: parsedCpeArgs.data.limit,
+                            total_returned: result.cpes.length
+                        };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(formattedResult, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: error.message,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@burtthecoder/mcp-shodan",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A Model Context Protocol server for Shodan API queries.",
   "main": "./build/index.js",
   "bin": {