This is page 1 of 2. Use http://codebase.md/cyproxio/mcp-for-security?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .dockerignore
├── .DS_Store
├── .github
│ └── workflows
│ └── docker.yml
├── .gitignore
├── alterx-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── amass-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── arjun-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── assetfinder-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── cero
│ ├── .gitignore
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── commix-mcp
│ ├── .gitignore
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── crtsh-mcp
│ ├── .gitignore
│ ├── build
│ │ ├── crtsh.js
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ ├── crtsh.ts
│ │ └── index.ts
│ └── tsconfig.json
├── Dockerfile
├── ffuf-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── gowitness-mcp
│ ├── .gitignore
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── http-headers-security-mcp
│ ├── .gitignore
│ ├── build
│ │ ├── index.js
│ │ ├── owasp_headers_add.json
│ │ └── owasp_headers_remove.json
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ ├── index.ts
│ │ ├── owasp_headers_add.json
│ │ └── owasp_headers_remove.json
│ └── tsconfig.json
├── httpx-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── katana-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── LICENSE
├── masscan-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── mobsf-mcp
│ ├── .gitignore
│ ├── build
│ │ ├── index.js
│ │ └── mobsf.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ ├── index.ts
│ │ └── mobsf.ts
│ └── tsconfig.json
├── nmap-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── nuclei-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── readme.md
├── scoutsuite-mcp
│ ├── .gitignore
│ ├── build
│ │ ├── index.js
│ │ └── parser.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ ├── index.ts
│ │ └── parser.ts
│ └── tsconfig.json
├── shuffledns-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── smuggler-mcp
│ ├── .gitignore
│ ├── build.sh
│ ├── LICENSE
│ ├── mcp.json
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── sqlmap-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── sslscan-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
├── start.sh
├── waybackurls-mcp
│ ├── .gitignore
│ ├── build
│ │ └── index.js
│ ├── build.sh
│ ├── package-lock.json
│ ├── package.json
│ ├── readme.md
│ ├── src
│ │ └── index.ts
│ └── tsconfig.json
└── wpscan-mcp
├── .gitignore
├── build.sh
├── package-lock.json
├── package.json
├── readme.md
├── src
│ └── index.ts
└── tsconfig.json
```
# Files
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
1 | mcp-config.json
```
--------------------------------------------------------------------------------
/smuggler-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | node_modules/
2 | build/
3 | *.log
```
--------------------------------------------------------------------------------
/ffuf-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | node_modules/
2 | jspm_packages/
3 | build/
```
--------------------------------------------------------------------------------
/alterx-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/amass-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/arjun-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/assetfinder-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/cero/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/commix-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/crtsh-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/http-headers-security-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/httpx-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/katana-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/masscan-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/mobsf-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/nmap-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/nuclei-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/scoutsuite-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/shuffledns-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/sqlmap-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/sslscan-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/waybackurls-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/wpscan-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Dependency directories
2 | node_modules/
3 | jspm_packages/
4 | build/
```
--------------------------------------------------------------------------------
/gowitness-mcp/.gitignore:
--------------------------------------------------------------------------------
```
1 | node_modules
2 | screenshots
3 | test-output
4 | test-screenshots
5 | test-runner.js
6 | build/
```
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
```
1 | # Git metadata
2 | .git
3 | .gitignore
4 |
5 | **/node_modules
6 |
7 | **/build
8 |
9 | # Log dosyaları
10 | *.log
11 | npm-debug.log
12 |
13 | tmp
14 | *.tmp
15 | .vscode
16 | .idea
17 |
18 | .env
19 | .env.local
20 | .env.*.local
21 |
22 | Dockerfile
23 | README.md
24 | *.md
25 | tests
```
--------------------------------------------------------------------------------
/commix-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 |
```
--------------------------------------------------------------------------------
/smuggler-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Smuggler MCP
2 |
3 | > Model Context Protocol (MCP) integration for Smuggler, a tool for detecting HTTP Request Smuggling / Desync vulnerabilities.
4 |
5 | ## Overview
6 |
7 | Smuggler MCP allows you to use the Smuggler HTTP Request Smuggling testing tool through the MCP protocol. This integration offers Smuggler's capabilities to automated security testing processes or AI assistants.
8 |
9 | ## Installation
10 |
11 | ### Prerequisites
12 |
13 | - Node.js (v16+)
14 | - Python 3.x
15 | - Smuggler (smuggler.py) downloaded from [defparam/smuggler](https://github.com/defparam/smuggler)
16 |
17 | ### Setup
18 |
19 | 1. Clone this repository:
20 | ```
21 | git clone https://github.com/cyproxio/mcp-for-security
22 | cd smuggler-mcp
23 | ```
24 |
25 | 2. Install dependencies:
26 | ```
27 | npm install
28 | ```
29 |
30 | 3. Build the project:
31 | ```
32 | npm install && npm run build
33 | ```
34 |
35 |
36 | ## Usage
37 |
38 | ### Basic Configuration
39 |
40 | To configure the Smuggler MCP server in your MCP client setup:
41 |
42 | ```json
43 | {
44 | "smuggler": {
45 | "command": "node",
46 | "args": [
47 | "/path/to/smuggler-mcp/build/index.js",
48 | "/path/to/python"
49 | "/path/to/smuggler/smuggler.py"
50 | ]
51 | }
52 | }
53 | ```
54 |
55 | ### Example Usage
56 |
57 | ```javascript
58 | // Run HTTP Request Smuggling test
59 | const result = await mcp.tools.invoke("do-smuggler", {
60 | url: "http://example.com"
61 | });
62 |
63 | // Test with additional parameters
64 | const result = await mcp.tools.invoke("do-smuggler", {
65 | url: "http://example.com",
66 | smuggler_args: ["-m", "GET", "--timeout", "10"]
67 | });
68 | ```
69 |
70 | ### Supported Parameters
71 |
72 | - `url`: URL to test (required)
73 | - `smuggler_args`: Additional Smuggler parameters (optional)
74 | - `-m, --method`: HTTP method (GET, POST, etc.)
75 | - `-v, --vhost`: Virtual host
76 | - `-t, --timeout`: Timeout value
77 | - `-x`: Exit on first finding
78 | - `--verify`: Level of verification for findings
79 |
80 | ## Integration with AI Assistants
81 | Smuggler MCP is designed to work with AI assistants that support the Model Context Protocol, enabling natural language interactions for vulnerability testing.
82 |
83 | ```
84 | User: Can you test this internal site for HTTP request smuggling? http://internal.corp
85 | AI: Running HTTP Request Smuggling tests on http://internal.corp using Smuggler...
86 |
87 | [AI runs Smuggler MCP and returns the parsed results]
88 |
89 | Smuggler found a potential CL.TE vulnerability using mutation XYZ...
90 | ```
91 | ## Security Considerations
92 |
93 | - Use Smuggler only with explicit authorization
94 | - Target only systems you own or have permission to test
95 | - Avoid triggering backend systems unintentionally
96 | - Use responsibly and ethically
97 |
98 |
99 | ## Troubleshooting
100 |
101 | 1. Verify Python and smuggler.py are accessible and working
102 | 2. Ensure the paths in your configuration are correct
103 | 3. Check output logs for Python errors
104 | 4. Use verbose logging for debugging
105 |
106 |
107 | ## Acknowledgements
108 |
109 | - [Smuggler](https://github.com/defparam/smuggler)
110 | - [Model Context Protocol](https://github.com/modelcontextprotocol)
```
--------------------------------------------------------------------------------
/scoutsuite-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Scout Suite MCP
2 |
3 | > Scout Suite MCP is a bridge that integrates Scout Suite, a multi-cloud security auditing tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 |
6 | ## Overview
7 |
8 | Scout Suite MCP enables automated security auditing of cloud environments (AWS, Azure, GCP) using Scout Suite’s powerful capabilities, accessible through the standardized MCP interface. It allows AI assistants and automation tools to perform in-depth cloud configuration analysis, detect potential misconfigurations, and generate comprehensive security reports.
9 |
10 |
11 | ## Features
12 |
13 | - Multi-cloud support (AWS, Azure, GCP)
14 | - Service and region-based filtering
15 | - Multiple authentication methods (profile or access keys)
16 | - Summary or full report generation
17 | - Custom IP range mapping support
18 | - Seamless integration with AI assistants via MCP
19 | - Clean JSON output for further automation or reporting
20 |
21 | ### Cloud Providers Supported
22 |
23 | | Provider | Description |
24 | |------|-------------|
25 | |AWS|Audit AWS accounts using profile or access keys. Filter services and regions.
26 | |Azure|(Coming soon) Audit Azure subscriptions with token-based authentication.
27 | |GCP|(Coming soon) Audit GCP projects via service account JSON credentials.
28 |
29 |
30 | ## Installation
31 |
32 | ### Prerequisites
33 |
34 | - Node.js (v16 or higher)
35 | - Scout Suite installed on your system
36 | - MCP SDK
37 |
38 | ### Setup
39 |
40 | 1. Clone this repository:
41 | ```
42 | git clone https://github.com/cyproxio/mcp-for-security
43 | cd Scout Suite-mcp
44 | ```
45 |
46 | 2. Install dependencies:
47 | ```
48 | npm install
49 | ```
50 |
51 | 3. Build the project:
52 | ```
53 | npm install && npm run build
54 | ```
55 |
56 | ## Usage
57 |
58 | ### Basic Configuration
59 |
60 | Configure the Scout Suite MCP server in your MCP client configuration:
61 |
62 | ```json
63 | {
64 | "Scout Suite": {
65 | "command": "node",
66 | "args": [
67 | "/path/to/Scout Suite-mcp/build/index.js",
68 | "/path/to/scoutsuite binary"
69 | ]
70 | }
71 | }
72 | ```
73 |
74 |
75 | ## Examples
76 |
77 | ### Audit an AWS Account
78 |
79 | ```javascript
80 | const result = await mcp.tools.invoke("do-Scout Suite-aws", {
81 | profile: "prod-account",
82 | services: ["ec2", "s3", "iam"],
83 | regions: "us-east-1,eu-central-1",
84 | full_report: false
85 | });
86 | ```
87 |
88 |
89 | ## Integration with AI Assistants
90 | Scout Suite MCP is designed for direct use by AI agents to perform cloud security assessments through natural language requests.
91 |
92 | Example conversation with an AI assistant:
93 |
94 | ```
95 | User: Audit our AWS environment for misconfigurations.
96 | AI: Running Scout Suite on AWS using profile "prod-account"...
97 | [Scout Suite MCP invoked and returns the results] ...
98 | ```
99 |
100 | ## Troubleshooting
101 |
102 | If you encounter issues:
103 |
104 | 1. Ensure scout suite is installed and accessible in your terminal (which scout).
105 | 2. Make sure your MCP configuration path points to the correct build output.
106 | 3. Verify that the target parameter is a valid domain.
107 | 4. Check logs for detailed error messages.
108 |
109 | ## Acknowledgments
110 |
111 | - Scout Suite by NCC Group: https://github.com/nccgroup/Scout Suite
112 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/cero/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # CERO MCP
2 |
3 | > Cero MCP is a bridge that connects Cero, a high-performance TLS certificate scanner, with the Model Context Protocol (MCP) ecosystem.
4 |
5 |
6 | ## Overview
7 |
8 | Cero MCP enables seamless integration of Cero’s TLS certificate-based domain enumeration capabilities into MCP-compatible applications and AI-powered reconnaissance workflows. This allows for automated subdomain discovery and infrastructure analysis, ideal for penetration testing pipelines, OSINT, and AI security agents.
9 |
10 | ## Installation
11 |
12 | ### Prerequisites
13 |
14 | - Node.js (v16+)
15 | - MCP SDK
16 | - Go 1.18+ (if building Cero from source)
17 | - Cero binary available in system path or specified manually
18 |
19 | ### Setup
20 |
21 | 1. Clone this repository:
22 | ```
23 | git clone https://github.com/cyproxio/mcp-for-security
24 | cd cero-mcp
25 | ```
26 |
27 | 2. Install dependencies:
28 | ```
29 | npm install
30 | ```
31 |
32 | 3. Build the project:
33 | ```
34 | npm run build
35 | ```
36 |
37 |
38 | ## Usage
39 |
40 | ### Basic Configuration
41 |
42 | To configure the Cero MCP server in your MCP client setup:
43 |
44 | ```json
45 | {
46 | "cero": {
47 | "command": "node",
48 | "args": [
49 | "/path/to/cero-mcp/build/index.js",
50 | "/usr/local/bin/cero"
51 | ]
52 | }
53 | }
54 | ```
55 |
56 | ### Example Usage
57 |
58 | #### Basic TSL Scan
59 | ```javascript
60 | const result = await mcp.tools.invoke("do-cero", {
61 | target: "example.com"
62 | });
63 | ```
64 |
65 | #### Concurrent Scan with Custom Ports and Timeout
66 | ```javascript
67 | const result = await mcp.tools.invoke("do-cero", {
68 | target: "192.168.1.0/24",
69 | concurrency: 100,
70 | ports: ["443", "8443", "993"],
71 | timeOut: 6
72 | });
73 | ```
74 |
75 | ### Supported Parameters
76 |
77 | - `target` (required): The target hostname, IP address, or CIDR range to scan
78 | - `concurrency`: Maximum number of concurrent TLS connections (default varies)
79 | - `ports`: List of ports to probe for TLS certificates (e.g., ["443", "8443"])
80 | - `timeOut`: Timeout for each TLS connection in seconds (default: 4)
81 |
82 | ## Integration with AI Assistants
83 | Cero MCP integrates directly into AI assistants that support the Model Context Protocol. This allows natural language instructions to trigger deep certificate-based enumeration.
84 |
85 | ```
86 | User: Find subdomains for *.example.com using TLS certificate data.
87 | AI: Running Cero scan against example.com on ports 443 and 8443...
88 |
89 | [Cero MCP runs and returns discovered domains]
90 |
91 | Results: Found 6 domains via certificate SAN fields including mail.example.com and api.example.com.
92 | ```
93 | ## Security Considerations
94 |
95 | - Only scan IP ranges and hosts you are authorized to assess
96 | - Excessive concurrency can lead to rate-limiting or blacklisting
97 | - Always validate certificate data manually before further use
98 | - Timeout values may affect results in high-latency environments
99 |
100 |
101 | ## Troubleshooting
102 |
103 | 1. Ensure the Cero binary is installed and accessible from the command line
104 | 2. Confirm network access to the target IP or domain
105 | 3. Make sure the target is accessible and valid
106 |
107 |
108 | ## Acknowledgements
109 |
110 | - [cero](https://github.com/glebarez/cero)
111 | - [Model Context Protocol](https://github.com/modelcontextprotocol)
```
--------------------------------------------------------------------------------
/ffuf-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # FFUF MCP
2 |
3 | > FFUF MCP is a bridge that connects FFUF (Fuzz Faster U Fool), the high-speed web fuzzer, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | FFUF MCP enables seamless integration of FFUF's powerful web fuzzing capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage FFUF functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full FFUF functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - FFUF installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd ffuf-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the FFUF MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "ffuf": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/ffuf-mcp/build/index.js",
54 | "ffuf"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running FFUF Tests
61 |
62 | Once configured, you can run FFUF tests through the MCP interface using the `do-ffuf` tool:
63 |
64 | ```javascript
65 | // Example of calling FFUF through MCP
66 | const result = await mcp.tools.invoke("do-ffuf", {
67 | url: "http://example.com/FUZZ",
68 | ffuf_args: ["-w", "/path/to/wordlist.txt"]
69 | });
70 | ```
71 |
72 | ### Available Options
73 |
74 | FFUF MCP supports all standard FFUF parameters.
75 | See the [FFUF documentation](https://github.com/ffuf/ffuf) for a full list of available options.
76 |
77 | ## Examples
78 |
79 | ### Directory Fuzzing
80 |
81 | ```javascript
82 | const result = await mcp.tools.invoke("do-ffuf", {
83 | url: "http://target-website.com/FUZZ",
84 | ffuf_args: [
85 | "-w", "/path/to/common-directories.txt",
86 | "-mc", "200,204,301,302,307,401,403"
87 | ]
88 | });
89 | ```
90 |
91 | ## Integration with AI Assistants
92 |
93 | FFUF MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
94 |
95 | Example conversation with an AI assistant:
96 |
97 | ```
98 | User: Fuzz for hidden directories on http://example.com
99 | AI: I'll help you fuzz for hidden directories using FFUF.
100 |
101 | [AI uses FFUF MCP to run the test and returns the results]
102 |
103 | FFUF has discovered the following directories:
104 | - /admin (Status: 301)
105 | - /api (Status: 200)
106 | - /backup (Status: 403)
107 | ...
108 | ```
109 |
110 | ## Troubleshooting
111 |
112 | If you encounter issues:
113 |
114 | 1. Verify FFUF is properly installed and accessible
115 | 2. Check the path to the FFUF executable in your configuration
116 | 3. Ensure proper permissions are set for execution
117 | 4. Review server logs for detailed error messages
118 |
119 | ## Acknowledgments
120 |
121 | - FFUF Project: https://github.com/ffuf/ffuf
122 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/nmap-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Nmap MCP
2 |
3 | > Nmap MCP is a bridge that connects Nmap, the industry-standard network scanner, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Nmap MCP enables seamless integration of Nmap's comprehensive network scanning and security auditing capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Nmap's functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full Nmap functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - Nmap installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd nmap-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the Nmap MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "nmap": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/nmap-mcp/build/index.js",
54 | "nmap"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running Nmap Scans
61 |
62 | Once configured, you can run Nmap scans through the MCP interface using the `do-nmap` tool:
63 |
64 | ```javascript
65 | // Example of calling Nmap through MCP
66 | const result = await mcp.tools.invoke("do-nmap", {
67 | target: "192.168.1.1",
68 | nmap_args: ["-sV", "-p", "1-1000"]
69 | });
70 | ```
71 |
72 | ### Available Options
73 |
74 | Nmap MCP supports all standard Nmap parameters through the `nmap_args` array.
75 |
76 | ## Examples
77 |
78 | ### Basic Port Scan
79 |
80 | ```javascript
81 | const result = await mcp.tools.invoke("do-nmap", {
82 | target: "192.168.1.1",
83 | nmap_args: ["-p", "1-1000"]
84 | });
85 | ```
86 | ## Integration with AI Assistants
87 |
88 | Nmap MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
89 |
90 | Example conversation with an AI assistant:
91 |
92 | ```
93 | User: Scan the host 192.168.1.1 for open web servers and SSH
94 | AI: I'll help you scan that host using Nmap.
95 |
96 | [AI uses Nmap MCP to run the scan and returns the results]
97 |
98 | Nmap scan results for 192.168.1.1:
99 | - Port 22/tcp: open (SSH)
100 | - Port 80/tcp: open (HTTP)
101 | - Port 443/tcp: open (HTTPS)
102 | ...
103 | ```
104 |
105 | ## Security Considerations
106 |
107 | - Always obtain proper authorization before scanning networks
108 | - Use responsibly and ethically
109 | - Be aware that some Nmap scan types can be detected by security systems
110 | - Consider using quieter scan options in sensitive environments
111 |
112 | ## Troubleshooting
113 |
114 | If you encounter issues:
115 |
116 | 1. Verify Nmap is properly installed and accessible
117 | 2. Check the path to the Nmap executable in your configuration
118 | 3. Ensure proper permissions are set for execution (some Nmap scan types require root/administrator privileges)
119 | 4. Review server logs for detailed error messages
120 |
121 | ## Acknowledgments
122 |
123 | - Nmap Project: https://nmap.org
124 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/assetfinder-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Assetfinder MCP
2 |
3 | > Assetfinder MCP is a bridge that connects Assetfinder, a subdomain discovery tool by Tomnomnom, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Assetfinder MCP enables seamless integration of Assetfinder’s passive subdomain enumeration capabilities into MCP-compatible applications and AI-powered systems. This allows automated workflows and AI assistants to quickly discover related domains and subdomains for reconnaissance and analysis using a standardized interface.
8 |
9 |
10 | ## Features
11 |
12 | - Integration with Assetfinder for passive subdomain discovery
13 | - Fast and lightweight enumeration of subdomains
14 | - Optional discovery of related root domains
15 | - Seamless usage within AI assistants or automation pipelines
16 | - Standardized input/output handling through MCP
17 |
18 | ## Installation
19 |
20 | ### Prerequisites
21 |
22 | - Node.js (v16 or higher)
23 | - assetfinder installed on your system
24 | - MCP SDK
25 |
26 | ### Setup
27 |
28 | 1. Clone this repository:
29 | ```
30 | git clone https://github.com/cyproxio/mcp-for-security
31 | cd assetfinder-mcp
32 | ```
33 |
34 | 2. Install dependencies:
35 | ```
36 | npm install
37 | ```
38 |
39 | 3. Build the project:
40 | ```
41 | npm install && npm run build
42 | ```
43 |
44 | ## Usage
45 |
46 | ### Basic Configuration
47 |
48 | Configure the Assetfinder MCP server in your MCP client configuration:
49 |
50 | ```json
51 | {
52 | "assetfinder": {
53 | "command": "node",
54 | "args": [
55 | "/path/to/assetfinder-mcp/build/index.js",
56 | "assetfinder"
57 | ]
58 | }
59 | }
60 | ```
61 |
62 | ### Parameters
63 | Assetfinder MCP supports the following parameter:
64 | * target: The domain name to enumerate subdomains for (e.g., example.com).
65 |
66 |
67 | ## Examples
68 |
69 | ### Basic Subdomain Enumeration
70 |
71 | ```javascript
72 | const result = await mcp.tools.invoke("assetfinder", {
73 | target: "example.com"
74 | });
75 | ```
76 |
77 | ### Use in an Automated Workflow
78 |
79 | ```javascript
80 | const domains = ["example.com", "testsite.org"];
81 | for (const domain of domains) {
82 | const result = await mcp.tools.invoke("assetfinder", { target: domain });
83 | console.log(`${domain} → ${result.join(", ")}`);
84 | }
85 | ```
86 |
87 |
88 | ## Integration with AI Assistants
89 | Assetfinder MCP is designed to be easily used within AI assistants that support the Model Context Protocol. This allows natural language-driven subdomain reconnaissance tasks.
90 |
91 | Example conversation with an AI assistant:
92 |
93 | ```
94 | User: Find all subdomains of example.com.
95 | AI: Running assetfinder for example.com...
96 |
97 | [AI uses Assetfinder MCP and returns the results]
98 |
99 | I found the following subdomains:
100 | - www.example.com
101 | - api.example.com
102 | - mail.example.com
103 | ...
104 | ```
105 |
106 | ## Security Considerations
107 |
108 | - Assetfinder performs passive enumeration and does not actively scan the target.
109 | - Ensure you have proper authorization to query domains.
110 | - Use responsibly and in accordance with legal and ethical guidelines.
111 |
112 | ## Troubleshooting
113 |
114 | If you encounter issues:
115 |
116 | 1. Ensure assetfinder is installed and accessible in your terminal (which assetfinder).
117 | 2. Make sure your MCP configuration path points to the correct build output.
118 | 3. Verify that the target parameter is a valid domain.
119 | 4. Check logs for detailed error messages.
120 |
121 | ## Acknowledgments
122 |
123 | - Assetfinder by Tomnomnom: https://github.com/tomnomnom/assetfinder
124 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/masscan-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Masscan MCP
2 |
3 | > Masscan MCP is a bridge that connects Masscan, the ultra-fast port scanner, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Masscan MCP enables seamless integration of Masscan's high-speed network scanning capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Masscan functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full Masscan functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - Masscan installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd masscan-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the Masscan MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "masscan": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/masscan-mcp/build/index.js",
54 | "masscan"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running Masscan
61 |
62 | Once configured, you can run Masscan through the MCP interface using the `do-masscan` tool:
63 |
64 | ```javascript
65 | // Example of calling Masscan through MCP
66 | const result = await mcp.tools.invoke("do-masscan", {
67 | target: "192.168.1.0/24",
68 | port: "80,443,8080"
69 | });
70 | ```
71 |
72 | ### Parameters
73 |
74 | Masscan MCP currently supports two main parameters:
75 |
76 | - `target`: IP address or range to scan (e.g., "192.168.1.1", "10.0.0.0/24")
77 | - `port`: Port or port ranges to scan (e.g., "80", "22-25", "80,443,8080")
78 |
79 | ## Examples
80 |
81 | ### Scan a Single Host
82 |
83 | ```javascript
84 | const result = await mcp.tools.invoke("do-masscan", {
85 | target: "192.168.1.1",
86 | port: "1-65535"
87 | });
88 | ```
89 |
90 | ## Integration with AI Assistants
91 |
92 | Masscan MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
93 |
94 | Example conversation with an AI assistant:
95 |
96 | ```
97 | User: Scan my local network 192.168.1.0/24 for web servers
98 | AI: I'll help you scan your network for web servers using Masscan.
99 |
100 | [AI uses Masscan MCP to run the scan and returns the results]
101 |
102 | Masscan has found the following open web ports:
103 | - 192.168.1.5:80
104 | - 192.168.1.10:443
105 | - 192.168.1.15:8080
106 | ...
107 | ```
108 |
109 | ## Security Considerations
110 |
111 | - Always obtain proper authorization before scanning networks
112 | - Use responsibly and ethically
113 | - Be aware that Masscan is designed for speed and may generate significant network traffic
114 | - Consider using slower scan rates in production environments
115 |
116 | ## Troubleshooting
117 |
118 | If you encounter issues:
119 |
120 | 1. Verify Masscan is properly installed and accessible
121 | 2. Check the path to the Masscan executable in your configuration
122 | 3. Ensure proper permissions are set for execution (Masscan typically requires root/administrator privileges)
123 | 4. Review server logs for detailed error messages
124 |
125 | ## Advanced Usage
126 |
127 | While the current MCP implementation provides basic functionality, Masscan itself supports many advanced features. Future versions of this bridge may include additional parameters.
128 |
129 | ## Acknowledgments
130 |
131 | - Masscan Project: https://github.com/robertdavidgraham/masscan
132 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/wpscan-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # WPSCAN MCP
2 |
3 | > WPScan MCP is a bridge that connects WPScan, a powerful WordPress vulnerability scanner, with the Model Context Protocol (MCP) ecosystem.
4 |
5 |
6 | ## Overview
7 |
8 | WPScan MCP enables seamless integration of WPScan’s advanced WordPress vulnerability scanning features into MCP-compatible applications and AI-powered security workflows. This allows for automated, standardized reconnaissance and enumeration of WordPress websites, ideal for penetration testing pipelines and AI security assistants.
9 |
10 | ## Installation
11 |
12 | ### Prerequisites
13 |
14 | - Node.js (v16+)
15 | - MCP SDK
16 | - WPScan installed and executable from the command line
17 |
18 | ### Setup
19 |
20 | 1. Clone this repository:
21 | ```
22 | git clone https://github.com/cyproxio/mcp-for-security
23 | cd wpscan-mcp
24 | ```
25 |
26 | 2. Install dependencies:
27 | ```
28 | npm install
29 | ```
30 |
31 | 3. Build the project:
32 | ```
33 | npm install && npm run build
34 | ```
35 |
36 |
37 | ## Usage
38 |
39 | ### Basic Configuration
40 |
41 | To configure the Smuggler MCP server in your MCP client setup:
42 |
43 | ```json
44 | {
45 | "wpscan": {
46 | "command": "node",
47 | "args": [
48 | "/path/to/wpscan-mcp/build/index.js",
49 | "/usr/bin/wpscan"
50 | ]
51 | }
52 | }
53 | ```
54 |
55 | ### Example Usage
56 |
57 | #### Basic Scan
58 | ```javascript
59 | const result = await mcp.tools.invoke("do-wpscan", {
60 | url: "https://example.com",
61 | enumerate: ["vp", "vt", "tt", "cb", "dbe"]
62 | });
63 | ```
64 |
65 | #### Stealthier Scan with Proxy and Random Agent
66 | ```javascript
67 | const result = await mcp.tools.invoke("do-wpscan", {
68 | url: "https://example.com",
69 | detection_mode: "passive",
70 | proxy: "http://127.0.0.1:8080",
71 | random_user_agent: true
72 | });
73 | ```
74 |
75 | ### Supported Parameters
76 |
77 | - `url` (required): The target WordPress site to scan
78 | - `detection_mode`: "mixed" (default), "passive", or "aggressive"
79 | - `random_user_agent`: Whether to rotate user agents to avoid detection
80 | - `max_threads`: Number of threads to speed up scanning (default: 5)
81 | - `disable_tls_checks`: Disable TLS certificate validation
82 | - `proxy`: Proxy to route traffic through (e.g., http://127.0.0.1:8080)
83 | - `cookies`: Cookie string to use (e.g., PHPSESSID=1234; logged_in=true)
84 | - `force`: Force scanning even if WP is not detected
85 | - `enumerate`: Array of enumeration types:
86 | - `vp`: Vulnerable plugins
87 | - `ap`: All plugins
88 | - `p`: Popular plugins
89 | - `vt`: Vulnerable themes
90 | - `at`: All themes
91 | - `t`: Popular themes
92 | - `tt`: Timthumb vulnerabilities
93 | - `cb`: Configuration backups
94 | - `dbe`: Database exports
95 |
96 | ## Integration with AI Assistants
97 | WPScan MCP works seamlessly with AI assistants that support the Model Context Protocol. This allows natural language commands to trigger WPScan in real-time.
98 |
99 | ```
100 | User: Scan https://example.com for WordPress vulnerabilities.
101 | AI: Running WPScan against https://example.com using passive detection...
102 |
103 | [WPScan MCP runs and returns findings]
104 |
105 | Results: 3 vulnerable plugins found, 1 outdated theme, timthumb vulnerability detected.
106 | ```
107 | ## Security Considerations
108 |
109 | - Only scan sites you own or have explicit permission to test
110 | - Aggressive scanning can trigger security alerts on target websites
111 | - Passive mode is recommended for stealthy enumeration
112 | - Always review output manually before making security decisions
113 |
114 |
115 | ## Troubleshooting
116 |
117 | 1. Ensure WPScan is installed and executable from CLI
118 | 2. Validate proxy and TLS settings are correct
119 | 3. Make sure the URL is accessible and valid
120 | 4. Use verbose output or server logs for error tracking
121 |
122 |
123 | ## Acknowledgements
124 |
125 | - [WPScan](https://github.com/wpscanteam/wpscan)
126 | - [Model Context Protocol](https://github.com/modelcontextprotocol)
```
--------------------------------------------------------------------------------
/sqlmap-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # SQLMap MCP
2 |
3 | > SQLMap MCP is a bridge that connects SQLMap, the popular SQL injection detection and exploitation tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | SQLMap MCP enables seamless integration of SQLMap's powerful SQL injection testing capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage SQLMap functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full SQLMap functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - SQLMap installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd sqlmap-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the SQLMap MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "sqlmap": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/sqlmap-mcp/build/index.js",
54 | "sqlmap"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running SQLMap Tests
61 |
62 | Once configured, you can run SQLMap tests through the MCP interface using the `do-sqlmap` tool:
63 |
64 | ```javascript
65 | // Example of calling SQLMap through MCP
66 | const result = await mcp.tools.invoke("do-sqlmap", {
67 | url: "http://example.com/vulnerable.php?id=1",
68 | sqlmap_args: ["--batch", "--dbs"]
69 | });
70 | ```
71 |
72 | ### Available Options
73 |
74 | SQLMap MCP supports all standard SQLMap parameters.
75 | See the [SQLMap documentation](https://github.com/sqlmapproject/sqlmap/wiki/Usage) for a full list of available options.
76 |
77 | ## Examples
78 |
79 | ### Basic Database Enumeration
80 |
81 | ```javascript
82 | const result = await mcp.tools.invoke("do-sqlmap", {
83 | url: "http://vulnerable-website.com/page.php?id=1",
84 | sqlmap_args: ["--batch", "--dbs"]
85 | });
86 | ```
87 |
88 | ### Targeted Table Dump
89 |
90 | ```javascript
91 | const result = await mcp.tools.invoke("do-sqlmap", {
92 | url: "http://vulnerable-website.com/page.php?id=1",
93 | sqlmap_args: [
94 | "--batch",
95 | "-D", "target_database",
96 | "-T", "users",
97 | "--dump"
98 | ]
99 | });
100 | ```
101 |
102 | ## Integration with AI Assistants
103 |
104 | SQLMap MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
105 |
106 | Example conversation with an AI assistant:
107 |
108 | ```
109 | User: Test this website for SQL injection: http://testphp.vulnweb.com/artists.php?artist=1
110 | AI: I'll help you test that website for SQL injection vulnerabilities using SQLMap.
111 |
112 | [AI uses SQLMap MCP to run the test and returns the results]
113 |
114 | SQLMap has detected a potential SQL injection vulnerability in the 'artist' parameter...
115 | ```
116 |
117 | ## Security Considerations
118 |
119 | - Always obtain proper authorization before testing websites for vulnerabilities
120 | - Use responsibly and ethically
121 | - Consider using `--random-agent` and proxies for more discreet testing
122 |
123 | ## Troubleshooting
124 |
125 | If you encounter issues:
126 |
127 | 1. Verify SQLMap is properly installed and accessible
128 | 2. Check the path to the SQLMap executable in your configuration
129 | 3. Ensure proper permissions are set for execution
130 | 4. Review server logs for detailed error messages
131 |
132 | ## Acknowledgments
133 |
134 | - SQLMap Project: https://github.com/sqlmapproject/sqlmap
135 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/arjun-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Arjun MCP
2 |
3 | > Arjun MCP is a bridge that connects Arjun, a powerful HTTP parameter discovery tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 |
6 |
7 | ## Overview
8 |
9 | Arjun MCP enables seamless integration of Arjun’s advanced hidden parameter discovery capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Arjun’s comprehensive scanning features through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
10 |
11 |
12 | ## Features
13 |
14 | - Integration with Arjun to discover hidden HTTP parameters
15 | - Support for scanning single URLs or multiple URLs from a file
16 | - Custom wordlist support for flexible scanning
17 | - Ability to specify HTTP methods (GET, POST, JSON, HEADERS)
18 | - Rate limiting and chunk size configuration
19 | - Simple configuration and setup
20 | - Easy integration with other MCP-compatible tools and systems
21 | - Standardized input/output handling
22 |
23 | ## Installation
24 |
25 | ### Prerequisites
26 |
27 | - Node.js (v16 or higher)
28 | - Arjun installed on your system
29 | - MCP SDK
30 |
31 | ### Setup
32 |
33 | 1. Clone this repository:
34 | ```
35 | git clone https://github.com/cyproxio/mcp-for-security
36 | cd arjun-mcp
37 | ```
38 |
39 | 2. Install dependencies:
40 | ```
41 | npm install
42 | ```
43 |
44 | 3. Build the project:
45 | ```
46 | npm install && npm run build
47 | ```
48 |
49 | ## Usage
50 |
51 | ### Basic Configuration
52 |
53 | Configure the Arjun MCP server in your MCP client configuration:
54 |
55 | ```json
56 | {
57 | "arjun": {
58 | "command": "node",
59 | "args": [
60 | "/path/to/arjun-mcp/build/index.js",
61 | "arjun"
62 | ]
63 | }
64 | }
65 | ```
66 |
67 | ### Parameters
68 | Arjun MCP supports the following parameters:
69 | - url: Target URL to scan for hidden parameters (required if textFile not provided)
70 | - textFile: Path to file containing multiple URLs (optional)
71 | - wordlist: Path to custom wordlist file for scanning (optional)
72 | - method: HTTP method to use for scanning (optional)
73 | - rateLimit: Maximum requests per second (optional, default: 9999)
74 | - chunkSize: The number of parameters to be sent at once (optional)
75 |
76 | ## Examples
77 |
78 | ### Scan a Single URL
79 |
80 | ```javascript
81 | const result = await mcp.tools.invoke("arjun", {
82 | url: "https://example.com"
83 | });
84 | ```
85 |
86 | ### Scan Multiple URLs from a File
87 |
88 | ```javascript
89 | const result = await mcp.tools.invoke("arjun", {
90 | textFile: "/path/to/urls.txt"
91 | });
92 | ```
93 |
94 |
95 | ### Use a Custom Wordlist and Specific Method
96 |
97 | ```javascript
98 | const result = await mcp.tools.invoke("arjun", {
99 | url: "https://example.com",
100 | wordlist: "/path/to/wordlist.txt",
101 | method: "POST"
102 | });
103 | ```
104 |
105 |
106 | ## Integration with AI Assistants
107 |
108 | Arjun MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for hidden parameter discovery tasks.
109 |
110 | Example conversation with an AI assistant:
111 |
112 | ```
113 | User: Find hidden parameters on https://example.com
114 | AI: I'll run a scan for hidden HTTP parameters on https://example.com using Arjun.
115 |
116 | [AI uses Arjun MCP to perform the scan and returns the results]
117 |
118 | I discovered the following hidden parameters:
119 | - user_id
120 | - session_token
121 | - debug
122 | - preview_mode
123 | ...
124 |
125 | Would you like me to test these parameters for vulnerabilities?
126 | ```
127 |
128 | ## Security Considerations
129 |
130 | - This tool is intended for legitimate security research and testing
131 | - Always obtain proper authorization before scanning websites
132 | - Scanning can generate noticeable traffic; adjust rate limits if necessary
133 | - Use responsibly and ethically
134 | - Respect target websites’ terms of service and applicable laws
135 |
136 | ## Troubleshooting
137 |
138 | If you encounter issues:
139 |
140 | 1. Verify Arjun is properly installed and accessible in your PATH
141 | 2. Check the path to the Arjun executable in your configuration
142 | 3. Ensure proper permissions are set for execution
143 | 4. Review server logs for detailed error messages
144 |
145 | ## Acknowledgments
146 |
147 | - Arjun Project: https://github.com/s0md3v/Arjun
148 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/sslscan-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # SSLScan MCP
2 |
3 | > SSLScan MCP is a bridge that connects SSLScan, the comprehensive SSL/TLS security testing tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | SSLScan MCP enables seamless integration of SSLScan's SSL/TLS assessment capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage SSLScan functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full SSLScan functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 | - Support for all SSLScan options and configurations
16 |
17 | ## Installation
18 |
19 | ### Prerequisites
20 |
21 | - Node.js (v16 or higher)
22 | - SSLScan installed on your system
23 | - MCP SDK
24 |
25 | ### Setup
26 |
27 | 1. Clone this repository:
28 | ```
29 | git clone https://github.com/cyproxio/mcp-for-security
30 | cd sslscan-mcp
31 | ```
32 |
33 | 2. Install dependencies:
34 | ```
35 | npm install
36 | ```
37 |
38 | 3. Build the project:
39 | ```
40 | npm install && npm run build
41 | ```
42 |
43 | ## Usage
44 |
45 | ### Basic Configuration
46 |
47 | Configure the SSLScan MCP server in your MCP client configuration:
48 |
49 | ```json
50 | {
51 | "sslscan": {
52 | "command": "node",
53 | "args": [
54 | "/path/to/sslscan-mcp/build/index.js",
55 | "sslscan"
56 | ]
57 | }
58 | }
59 | ```
60 |
61 | ### Running SSLScan Tests
62 |
63 | Once configured, you can run SSLScan tests through the MCP interface using the `do-sslscan` tool:
64 |
65 | ```javascript
66 | // Example of calling SSLScan through MCP
67 | const result = await mcp.tools.invoke("do-sslscan", {
68 | target: "https://example.com",
69 | sslscan_args: ["--no-fallback", "--no-heartbleed"]
70 | });
71 | ```
72 |
73 | ### Available Options
74 |
75 | SSLScan MCP supports all standard SSLScan parameters through the `sslscan_args` array.
76 |
77 | ## Examples
78 |
79 | ### Basic SSL/TLS Assessment
80 |
81 | ```javascript
82 | const result = await mcp.tools.invoke("do-sslscan", {
83 | target: "https://example.com",
84 | sslscan_args: []
85 | });
86 | ```
87 |
88 | ### Check for Legacy Protocol Support
89 |
90 | ```javascript
91 | const result = await mcp.tools.invoke("do-sslscan", {
92 | target: "https://example.com",
93 | sslscan_args: ["--ssl3", "--tls10"]
94 | });
95 | ```
96 |
97 | ### Comprehensive SSL/TLS Audit
98 |
99 | ```javascript
100 | const result = await mcp.tools.invoke("do-sslscan", {
101 | target: "https://example.com",
102 | sslscan_args: [
103 | "--show-certificate",
104 | "--show-ciphers",
105 | "--no-fallback",
106 | "--no-heartbleed"
107 | ]
108 | });
109 | ```
110 |
111 | ### STARTTLS for Email Servers
112 |
113 | ```javascript
114 | const result = await mcp.tools.invoke("do-sslscan", {
115 | target: "mail.example.com",
116 | sslscan_args: ["--starttls-smtp"]
117 | });
118 | ```
119 |
120 | ## Integration with AI Assistants
121 |
122 | SSLScan MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for SSL/TLS security testing tasks.
123 |
124 | Example conversation with an AI assistant:
125 |
126 | ```
127 | User: Check the SSL/TLS configuration of example.com
128 | AI: I'll help you analyze the SSL/TLS configuration of example.com using SSLScan.
129 |
130 | [AI uses SSLScan MCP to run the assessment and returns the results]
131 |
132 | SSLScan results for example.com:
133 | - TLSv1.0 is disabled
134 | - TLSv1.3 is supported
135 | - Weak ciphers are not supported
136 | - Certificate is valid and trusted
137 | - No Heartbleed vulnerability detected
138 | ...
139 | ```
140 |
141 | ## Security Considerations
142 |
143 | - Always obtain proper authorization before testing websites
144 | - Use responsibly and ethically
145 | - Some tests may be logged by the target server's security monitoring systems
146 |
147 | ## Troubleshooting
148 |
149 | If you encounter issues:
150 |
151 | 1. Verify SSLScan is properly installed and accessible
152 | 2. Check the path to the SSLScan executable in your configuration
153 | 3. Ensure proper permissions are set for execution
154 | 4. Review server logs for detailed error messages
155 | 5. Confirm that the target URL begins with `https://` for proper SSL/TLS scanning
156 |
157 | ## Acknowledgments
158 |
159 | - SSLScan Project: https://github.com/rbsec/sslscan
160 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/nuclei-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Nuclei MCP
2 |
3 | > Nuclei MCP is a bridge that connects Nuclei, the powerful vulnerability scanner, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Nuclei MCP enables seamless integration of Nuclei's template-based vulnerability scanning capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Nuclei functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Simple configuration and setup
12 | - Easy integration with other MCP-compatible tools and systems
13 | - Standardized input/output handling
14 | - Access to Nuclei's extensive template library
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - Nuclei installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd nuclei-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the Nuclei MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "nuclei": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/nuclei-mcp/build/index.js",
54 | "nuclei"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running Nuclei Scans
61 |
62 | Once configured, you can run Nuclei scans through the MCP interface using the `do-nuclei` tool:
63 |
64 | ```javascript
65 | // Example of calling Nuclei through MCP
66 | const result = await mcp.tools.invoke("do-nuclei", {
67 | url: "https://example.com",
68 | tags: "cve,rce,tech"
69 | });
70 | ```
71 |
72 | ### Getting Available Tags
73 |
74 | You can retrieve all available Nuclei template tags using the `get-nuclei-tags` tool:
75 |
76 | ```javascript
77 | // Get all available Nuclei tags
78 | const tagsResult = await mcp.tools.invoke("get-nuclei-tags", {});
79 | const tags = JSON.parse(tagsResult.content[0].text);
80 | ```
81 |
82 | ## Parameters
83 |
84 | Nuclei MCP currently supports the following parameters:
85 |
86 | - `url`: The target URL to scan (required)
87 | - `tags`: Comma-separated list of template tags to filter which checks to run (optional)
88 |
89 | ## Examples
90 |
91 | ### Basic Vulnerability Scan
92 |
93 | ```javascript
94 | const result = await mcp.tools.invoke("do-nuclei", {
95 | url: "https://target-website.com"
96 | });
97 | ```
98 |
99 | ### Targeted Scan with Specific Tags
100 |
101 | ```javascript
102 | const result = await mcp.tools.invoke("do-nuclei", {
103 | url: "https://target-website.com",
104 | tags: "cve,oast,ssrf"
105 | });
106 | ```
107 |
108 | ## Integration with AI Assistants
109 |
110 | Nuclei MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
111 |
112 | Example conversation with an AI assistant:
113 |
114 | ```
115 | User: Check example.com for common security vulnerabilities
116 | AI: I'll help you scan example.com for security vulnerabilities using Nuclei.
117 |
118 | [AI uses Nuclei MCP to run the scan and returns the results]
119 |
120 | Nuclei scan results for example.com:
121 | - Found CVE-2021-XXXX in the login page
122 | - Detected an open redirect vulnerability
123 | - Identified outdated WordPress version
124 | ...
125 | ```
126 |
127 | ## Security Considerations
128 |
129 | - Always obtain proper authorization before scanning websites for vulnerabilities
130 | - Use responsibly and ethically
131 | - Consider the potential impact of active scanning on production systems
132 | - Some templates may generate significant traffic or potentially disruptive tests
133 |
134 | ## Troubleshooting
135 |
136 | If you encounter issues:
137 |
138 | 1. Verify Nuclei is properly installed and accessible
139 | 2. Check the path to the Nuclei executable in your configuration
140 | 3. Ensure proper permissions are set for execution
141 | 4. Review server logs for detailed error messages
142 |
143 | ## Future Enhancements
144 |
145 | Future versions of this bridge may include additional parameters such as:
146 |
147 | - Support for more Nuclei options (rate-limiting, concurrency, etc.)
148 | - Template management and customization
149 | - Scan reporting in various formats
150 |
151 | ## Acknowledgments
152 |
153 | - Nuclei Project: https://github.com/projectdiscovery/nuclei
154 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/alterx-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Alterx MCP
2 |
3 | > Alterx MCP is a bridge that connects Alterx, a powerful subdomain permutation tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Alterx MCP enables seamless integration of Alterx's domain wordlist generation capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Alterx's pattern-based permutation system through a standardized protocol, making it easier to incorporate into automated subdomain discovery pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Pattern-based wordlist generation for subdomain discovery
12 | - Support for multiple permutation patterns and strategies
13 | - Simple configuration and setup
14 | - Easy integration with other MCP-compatible tools and systems
15 |
16 | ## Installation
17 |
18 | ### Prerequisites
19 |
20 | - Node.js (v16 or higher)
21 | - Alterx installed on your system
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd alterx-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the Alterx MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "alterx": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/alterx-mcp/build/index.js",
54 | "alterx"
55 | ]
56 | }
57 | }
58 | ```
59 |
60 | ### Running Alterx
61 |
62 | Once configured, you can run Alterx through the MCP interface using the `do-alterx` tool:
63 |
64 | ```javascript
65 | // Example of calling Alterx through MCP
66 | const result = await mcp.tools.invoke("do-alterx", {
67 | domain: "api.example.com",
68 | pattern: "{{word}}-{{sub}}.{{suffix}}",
69 | outputFilePath: "wordlist.txt"
70 | });
71 | ```
72 |
73 | ## Parameters
74 |
75 | Alterx MCP supports the following parameters:
76 |
77 | - `domain`: The target domain or subdomains to use as a base for creating permutations (required)
78 | - `pattern`: The pattern template to use for generating wordlist variations (required)
79 | - `outputFilePath`: Path where the generated wordlist should be saved (optional)
80 |
81 | ## Examples
82 |
83 | ### Basic Permutation
84 |
85 | ```javascript
86 | const result = await mcp.tools.invoke("do-alterx", {
87 | domain: "api.example.com",
88 | pattern: "{{sub}}-{{word}}.{{suffix}}"
89 | });
90 | ```
91 |
92 | ### Multiple Patterns
93 |
94 | ```javascript
95 | const result = await mcp.tools.invoke("do-alterx", {
96 | domain: "api.example.com",
97 | pattern: "{{sub}}-{{word}}.{{suffix}},{{word}}.{{sub}}.{{suffix}}",
98 | outputFilePath: "combined_wordlist.txt"
99 | });
100 | ```
101 |
102 | ## Integration with AI Assistants
103 |
104 | Alterx MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for subdomain discovery and enumeration tasks.
105 |
106 | Example conversation with an AI assistant:
107 |
108 | ```
109 | User: Generate subdomain permutations for api.example.com
110 | AI: I'll help you generate subdomain permutations using Alterx.
111 |
112 | [AI uses Alterx MCP to run the permutation and returns the results]
113 |
114 | I've generated the following subdomain permutations:
115 | - dev-api.example.com
116 | - stage-api.example.com
117 | - test-api.example.com
118 | - api-dev.example.com
119 | - api-stage.example.com
120 | ...
121 | ```
122 |
123 | ## Security Considerations
124 |
125 | - Always obtain proper authorization before scanning domains for subdomains
126 | - Use responsibly and ethically
127 | - This tool is intended for legitimate security research and testing
128 |
129 | ## Troubleshooting
130 |
131 | If you encounter issues:
132 |
133 | 1. Verify Alterx is properly installed and accessible
134 | 2. Check the path to the Alterx executable in your configuration
135 | 3. Ensure proper permissions are set for execution
136 | 4. Review server logs for detailed error messages
137 |
138 | ## Advanced Usage
139 |
140 | In more complex scenarios, you can:
141 |
142 | 1. Chain Alterx with other subdomain discovery tools in your MCP environment
143 | 2. Create custom wordlists for different patterns and reuse them across scans
144 | 3. Build automated workflows that generate permutations and then validate discovered subdomains
145 |
146 | ## Acknowledgments
147 |
148 | - Alterx Project: https://github.com/projectdiscovery/alterx
149 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/katana-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Katana MCP
2 |
3 | > Katana MCP is a bridge that connects Katana, a fast and customizable web crawler, with the Model Context Protocol (MCP) ecosystem.
4 |
5 |
6 | ## Overview
7 |
8 | Katana MCP enables seamless integration of Katana’s advanced crawling and endpoint discovery capabilities into MCP-compatible applications and AI-powered systems. This allows automated workflows and AI assistants to perform deep reconnaissance, link extraction, and JavaScript parsing using a standardized interface.
9 |
10 |
11 | ## Features
12 |
13 | - Integration with Katana for high-performance web crawling
14 | - JavaScript endpoint parsing and JSluice support
15 | - Configurable crawling strategies (depth-first or breadth-first)
16 | - Headless browser-based crawling (experimental)
17 | - Local Chrome integration support
18 | - Custom header and cookie injection
19 | - Easy integration with AI assistants or automated testing tools
20 | - Standardized input/output handling through MCP
21 |
22 | ## Installation
23 |
24 | ### Prerequisites
25 |
26 | - Node.js (v16 or higher)
27 | - katana installed on your system
28 | - MCP SDK
29 |
30 | ### Setup
31 |
32 | 1. Clone this repository:
33 | ```
34 | git clone https://github.com/cyproxio/mcp-for-security
35 | cd katana-mcp
36 | ```
37 |
38 | 2. Install dependencies:
39 | ```
40 | npm install
41 | ```
42 |
43 | 3. Build the project:
44 | ```
45 | npm install && npm run build
46 | ```
47 |
48 | ## Usage
49 |
50 | ### Basic Configuration
51 |
52 | Configure the Katana MCP server in your MCP client configuration:
53 |
54 | ```json
55 | {
56 | "katana": {
57 | "command": "node",
58 | "args": [
59 | "/path/to/katana-mcp/build/index.js",
60 | "katana"
61 | ]
62 | }
63 | }
64 | ```
65 |
66 | ### Parameters
67 | Katana MCP supports the following parameters:
68 | - target (required): List of target URLs (e.g., https://example.com) to scan.
69 | - exclude: URLs or patterns to exclude from crawling.
70 | - depth: Maximum crawl depth.
71 | - js_crawl: Enable endpoint parsing from JavaScript files.
72 | - jsluice: Enable memory-intensive JSluice parsing.
73 | - headers: List of custom headers/cookies in Header:Value format.
74 | - strategy: Crawling strategy (depth-first or breadth-first). Default: depth-first.
75 | - headless: Enable headless hybrid crawling using a browser (experimental).
76 | - system_chrome: Use system-installed Chrome instead of bundled version.
77 | - show_brwoser: Show the browser window even when headless mode is active.
78 |
79 | ## Examples
80 |
81 | ### Basic Crawl on a Single Target
82 |
83 | ```javascript
84 | const result = await mcp.tools.invoke("katana", {
85 | target: ["https://example.com"]
86 | });
87 | ```
88 |
89 | ### Crawl with JavaScript Parsing and Depth
90 |
91 | ```javascript
92 | const result = await mcp.tools.invoke("katana", {
93 | target: ["https://example.com"],
94 | depth: 3,
95 | js_crawl: true
96 | });
97 | ```
98 |
99 |
100 | ### Headless Browser Crawling with Custom Headers
101 |
102 | ```javascript
103 | const result = await mcp.tools.invoke("katana", {
104 | target: ["https://example.com"],
105 | headless: true,
106 | headers: ["Authorization: Bearer TOKEN", "Cookie: session=abcd1234"]
107 | });
108 | ```
109 |
110 |
111 | ## Integration with AI Assistants
112 | Katana MCP is optimized for use with AI assistants that support the Model Context Protocol. This enables natural language-driven reconnaissance and crawling tasks.
113 |
114 | Example conversation with an AI assistant:
115 |
116 | ```
117 | User: Crawl https://example.com and extract all endpoints.
118 | AI: Starting a deep crawl on https://example.com using Katana...
119 |
120 | [AI uses Katana MCP and returns the results]
121 |
122 | I found the following endpoints:
123 | - /api/user
124 | - /assets/js/app.js
125 | - /admin/dashboard
126 | ...
127 |
128 | Would you like to analyze the JavaScript files for hidden endpoints?
129 | ```
130 |
131 | ## Security Considerations
132 |
133 | - Use only on systems you are authorized to scan.
134 | - Crawling can be intensive and may be flagged as suspicious — adjust rate, depth, and headers appropriately.
135 | - Use responsibly and in compliance with legal and ethical standards.
136 |
137 | ## Troubleshooting
138 |
139 | If you encounter issues:
140 |
141 | 1. Ensure Katana is installed and accessible from your terminal.
142 | 2. Check that the command path in your MCP config points to the correct build file.
143 | 3. Validate all required parameters are passed.
144 | 4. Review logs for execution errors.
145 |
146 | ## Acknowledgments
147 |
148 | - Katana Project: https://github.com/projectdiscovery/katana
149 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/crtsh-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # CRTSH MCP
2 |
3 | > Certificate Search MCP is a bridge that connects crt.sh, a tool for discovering subdomains using SSL certificate logs, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Certificate Search MCP enables seamless integration of crt.sh's capability to discover subdomains into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage SSL certificate transparency logs to find subdomains, potentially hidden services, and expand attack surfaces through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Integration with Certificate Search (crt.sh) to fetch subdomains from SSL certificate logs
12 | - Comprehensive subdomain discovery without active scanning
13 | - Simple configuration and setup
14 | - Easy integration with other MCP-compatible tools and systems
15 | - Standardized input/output handling
16 |
17 | ## Installation
18 |
19 | ### Prerequisites
20 |
21 | - Node.js (v16 or higher)
22 | - MCP SDK
23 |
24 | ### Setup
25 |
26 | 1. Clone this repository:
27 | ```
28 | git clone https://github.com/cyproxio/mcp-for-security
29 | cd crtsh-mcp
30 | ```
31 |
32 | 2. Install dependencies:
33 | ```
34 | npm install
35 | ```
36 |
37 | 3. Build the project:
38 | ```
39 | npm install && npm run build
40 | ```
41 |
42 | ## Usage
43 |
44 | ### Basic Configuration
45 |
46 | Configure the Certificate Search MCP server in your MCP client configuration:
47 |
48 | ```json
49 | {
50 | "crtsh": {
51 | "command": "node",
52 | "args": [
53 | "/path/to/crtsh-mcp/build/index.js",
54 | ]
55 | }
56 | }
57 | ```
58 |
59 | ### Running crt.sh
60 |
61 | Once configured, you can run Certificate Search through the MCP interface using the `crtsh tool:
62 |
63 | ```javascript
64 | // Example of calling Certificate Search through MCP for a domain
65 | const result = await mcp.tools.invoke("crtsh", {
66 | target: "example.com"
67 | });
68 | ```
69 |
70 | ## Parameters
71 |
72 | Certificate Search MCP supports the following parameters:
73 |
74 | - `target`: The domain to retrieve subdomains for (required)
75 |
76 | ## Examples
77 |
78 | ### Gather All Historical URLs
79 |
80 | ```javascript
81 | const result = await mcp.tools.invoke("crtsh", {
82 | target: "example.com"
83 | });
84 | ```
85 |
86 | ### Process Results for Further Analysis
87 |
88 | ```javascript
89 | const result = await mcp.tools.invoke("crtsh", {
90 | target: "example.com"
91 | });
92 |
93 | // Parse the JSON results
94 | const domains = JSON.parse(result.content[0].text);
95 |
96 | // Filter for specific patterns or categories
97 | const devDomains = domains.filter(domain => domain.includes('dev'));
98 | const apiDomains = domains.filter(domain => domain.includes('api'));
99 | ```
100 |
101 | ## Integration with AI Assistants
102 |
103 | Certificate Search MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing and reconnaissance tasks.
104 |
105 | Example conversation with an AI assistant:
106 |
107 | ```
108 | User: Find subdomains for example.com
109 | AI: I'll discover subdomains for example.com using SSL certificate logs.
110 |
111 | [AI uses Certificate Search MCP to fetch the subdomains and returns the results]
112 |
113 | I found the following subdomains for example.com:
114 | - api.example.com
115 | - dev.example.com
116 | - staging.example.com
117 | - mail.example.com
118 | - intranet.example.com
119 | ...
120 | ```
121 |
122 | ## Security Considerations
123 |
124 | - This tool is intended for legitimate security research and testing
125 | - Always obtain proper authorization before scanning websites
126 | - Use responsibly and ethically
127 | - The tool only retrieves information already publicly available in certificate transparency logs
128 |
129 | ## Troubleshooting
130 |
131 | If you encounter issues:
132 |
133 | 1. Verify network connectivity to certificate transparency logs
134 | 2. Check that the domain has SSL certificates registered
135 | 3. Ensure proper permissions are set for execution
136 | 4. Review server logs for detailed error messages
137 | 5. Some domains may have limited or no certificates in transparency logs
138 |
139 | ## Usage Tips
140 |
141 | - Combine Certificate Search results with other reconnaissance tools for more comprehensive target information
142 | - Look for interesting or unusual subdomains that might indicate sensitive services
143 | - Use the discovered subdomains as input for further security testing
144 | - Regularly monitor changes in subdomain structure to identify new attack surfaces
145 |
146 | ## Acknowledgments
147 |
148 | - Certificate Search Project: https://crt.sh/
149 | - Certificate Transparency: https://certificate.transparency.dev/
150 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/mobsf-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # MobSF MCP
2 |
3 | > MobSF MCP is a bridge that connects Mobile Security Framework (MobSF), the automated mobile application security assessment tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | MobSF MCP enables seamless integration of MobSF's powerful mobile application security testing capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage MobSF's functionality through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - MobSF functionality exposed through MCP
12 | - Simple configuration and setup
13 | - Easy integration with other MCP-compatible tools and systems
14 | - Standardized input/output handling
15 | - Support for Android (APK), iOS (IPA), and Windows (APPX) mobile applications
16 |
17 | ## Installation
18 |
19 | ### Prerequisites
20 |
21 | - Node.js (v16 or higher)
22 | - MobSF server installed and running
23 | - MCP SDK
24 |
25 | ### Setup
26 |
27 | 1. Clone this repository:
28 | ```
29 | git clone https://github.com/cyproxio/mcp-for-security
30 | cd mobsf-mcp
31 | ```
32 |
33 | 2. Install dependencies:
34 | ```
35 | npm install
36 | ```
37 |
38 | 3. Build the project:
39 | ```
40 | npm install && npm run build
41 | ```
42 |
43 | ## Usage
44 |
45 | ### Basic Configuration
46 |
47 | Configure the MobSF MCP server in your MCP client configuration:
48 |
49 | ```json
50 | {
51 | "mobsf": {
52 | "command": "node",
53 | "args": [
54 | "/path/to/mobsf-mcp/build/index.js",
55 | "http://localhost:8000",
56 | "your_mobsf_api_key"
57 | ]
58 | }
59 | }
60 | ```
61 |
62 | The configuration requires two parameters:
63 | - The MobSF server URL (e.g., `http://localhost:8000`)
64 | - Your MobSF API key
65 |
66 | ### Available Tools
67 |
68 | MobSF MCP provides several tools for interacting with the MobSF server:
69 |
70 | #### uploadFile
71 |
72 | Upload a mobile application for analysis.
73 |
74 | ```javascript
75 | const result = await mcp.tools.invoke("uploadFile", {
76 | file: "/path/to/application.apk"
77 | });
78 | ```
79 |
80 | #### scanFile
81 |
82 | Scan a previously uploaded mobile application.
83 |
84 | ```javascript
85 | const result = await mcp.tools.invoke("scanFile", {
86 | hash: "file_hash_from_upload",
87 | reScan: false // Optional, set to true to force a rescan
88 | });
89 | ```
90 |
91 | #### getScanLogs
92 |
93 | Retrieve detailed scan logs for a previously analyzed application.
94 |
95 | ```javascript
96 | const result = await mcp.tools.invoke("getScanLogs", {
97 | hash: "file_hash"
98 | });
99 | ```
100 |
101 | #### getJsonReport
102 |
103 | Generate and retrieve a comprehensive security analysis report in JSON format.
104 |
105 | ```javascript
106 | const result = await mcp.tools.invoke("getJsonReport", {
107 | hash: "file_hash"
108 | });
109 | ```
110 |
111 | #### getRecentScans
112 |
113 | Retrieve a list of recently performed security scans.
114 |
115 | ```javascript
116 | const result = await mcp.tools.invoke("getRecentScans", {
117 | page: 1,
118 | pageSize: 10
119 | });
120 | ```
121 |
122 | ## Examples
123 |
124 | ### Complete Analysis Workflow
125 |
126 | ```javascript
127 | // Step 1: Upload the mobile application
128 | const uploadResult = await mcp.tools.invoke("uploadFile", {
129 | file: "/path/to/application.apk"
130 | });
131 |
132 | const fileHash = uploadResult.hash;
133 |
134 | // Step 2: Scan the uploaded application
135 | const scanResult = await mcp.tools.invoke("scanFile", {
136 | hash: fileHash
137 | });
138 |
139 | // Step 3: Generate a security report
140 | const reportResult = await mcp.tools.invoke("getJsonReport", {
141 | hash: fileHash
142 | });
143 |
144 | // Process the report data as needed
145 | ```
146 |
147 | ### Viewing Recent Scans
148 |
149 | ```javascript
150 | const recentScans = await mcp.tools.invoke("getRecentScans", {
151 | page: 1,
152 | pageSize: 20
153 | });
154 |
155 | // Process the list of recent scans
156 | ```
157 |
158 | ## Integration with AI Assistants
159 |
160 | MobSF MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for mobile application security testing.
161 |
162 | Example conversation with an AI assistant:
163 |
164 | ```
165 | User: Analyze this Android app for security vulnerabilities: /Downloads/my_app.apk
166 | AI: I'll help you analyze this Android application using MobSF.
167 |
168 | [AI uses MobSF MCP to upload and scan the app, then presents the results]
169 |
170 | Security Analysis Summary for my_app.apk:
171 | - 3 Critical vulnerabilities detected
172 | - 7 High-risk issues identified
173 | - Insecure data storage practices found
174 | - Excessive permissions requested
175 | ...
176 | ```
177 |
178 | ## Security Considerations
179 |
180 | - Always analyze applications you have permission to test
181 | - Keep your MobSF server and API keys secure
182 | - Consider the privacy implications of uploading sensitive applications
183 | - Use isolated environments for testing potentially malicious applications
184 |
185 | ## Troubleshooting
186 |
187 | If you encounter issues:
188 |
189 | 1. Verify the MobSF server is running and accessible
190 | 2. Check that your API key is correct and has not expired
191 | 3. Ensure file paths are correct and the files are accessible
192 | 4. Review server logs for detailed error messages
193 |
194 |
195 |
196 | ## Acknowledgments
197 |
198 | - MobSF Project: https://github.com/MobSF/Mobile-Security-Framework-MobSF
199 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/http-headers-security-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # HTTP Headers Security MCP
2 |
3 | > HTTP Headers Security MCP is a bridge that connects HTTP header security analysis capabilities with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | HTTP Headers Security MCP enables seamless integration of HTTP security header analysis into MCP-compatible applications and AI-powered workflow systems. This tool evaluates HTTP response headers against OWASP security best practices, identifying potentially dangerous headers that should be removed and recommended security headers that are missing. This bridge allows you to leverage security header analysis through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Analysis of HTTP response headers against OWASP security standards
12 | - Identification of security headers that should be removed
13 | - Recommendations for missing security headers that should be added
14 | - Simple configuration and setup
15 | - Easy integration with other MCP-compatible tools and systems
16 | - Standardized input/output handling
17 |
18 | ## Installation
19 |
20 | ### Prerequisites
21 |
22 | - Node.js (v16 or higher)
23 | - MCP SDK
24 | - Axios for HTTP requests
25 |
26 | ### Setup
27 |
28 | 1. Clone this repository:
29 | ```
30 | git clone https://github.com/cyproxio/mcp-for-security
31 |
32 | cd http-headers-security-mcp
33 | ```
34 |
35 | 2. Install dependencies:
36 | ```
37 | npm install
38 | ```
39 |
40 | 3. Build the project:
41 | ```
42 | npm install && npm run build
43 | ```
44 |
45 | ## Usage
46 |
47 | ### Basic Configuration
48 |
49 | Configure the HTTP Headers Security MCP server in your MCP client configuration:
50 |
51 | ```json
52 | {
53 | "http-headers-security": {
54 | "command": "node",
55 | "args": [
56 | "/path/to/http-headers-security-mcp/build/index.js"
57 | ]
58 | }
59 | }
60 | ```
61 |
62 | ### Analyzing HTTP Headers
63 |
64 | Once configured, you can analyze HTTP headers through the MCP interface using the `analyze-http-header` tool:
65 |
66 | ```javascript
67 | // Example of analyzing HTTP headers through MCP
68 | const result = await mcp.tools.invoke("analyze-http-header", {
69 | target: "https://example.com"
70 | });
71 |
72 | // Parse the JSON result
73 | const headerAnalysis = JSON.parse(result.content[0].text);
74 |
75 | // Access the results
76 | const headersToRemove = headerAnalysis.removeHeaders;
77 | const headersToAdd = headerAnalysis.addedHeaders;
78 | ```
79 |
80 | ## How It Works
81 |
82 | The HTTP Headers Security MCP works by:
83 |
84 | 1. Making an HTTP request to the target URL
85 | 2. Collecting all HTTP response headers
86 | 3. Comparing the headers against two OWASP-based reference lists:
87 | - Headers that should be removed for security reasons (from `owasp_headers_remove.json`)
88 | - Headers that should be added for enhanced security (from `owasp_headers_add.json`)
89 | 4. Returning a comprehensive analysis with specific recommendations
90 |
91 | ## Example Response
92 |
93 | ```json
94 | {
95 | "removeHeaders": [
96 | "Server: Apache/2.4.41",
97 | "X-Powered-By: PHP/7.4.3"
98 | ],
99 | "addedHeaders": [
100 | "Content-Security-Policy: default-src 'self'",
101 | "X-Frame-Options: DENY",
102 | "X-Content-Type-Options: nosniff",
103 | "Strict-Transport-Security: max-age=31536000; includeSubDomains"
104 | ]
105 | }
106 | ```
107 |
108 | ## Integration with AI Assistants
109 |
110 | HTTP Headers Security MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.
111 |
112 | Example conversation with an AI assistant:
113 |
114 | ```
115 | User: Check the security headers of example.com
116 | AI: I'll analyze the HTTP security headers for example.com.
117 |
118 | [AI uses HTTP Headers Security MCP to run the analysis and returns the results]
119 |
120 | Here's my security header analysis for example.com:
121 |
122 | Headers that should be removed:
123 | - Server: Apache/2.4.41 (reveals server software information)
124 | - X-Powered-By: PHP/7.4.3 (reveals technology stack)
125 |
126 | Missing security headers that should be added:
127 | - Content-Security-Policy: to prevent XSS attacks
128 | - X-Frame-Options: to prevent clickjacking
129 | - X-Content-Type-Options: to prevent MIME-type sniffing
130 | - Strict-Transport-Security: to enforce HTTPS
131 |
132 | These changes would significantly improve the security posture of the website.
133 | ```
134 |
135 | ## Security Considerations
136 |
137 | - Always obtain proper authorization before scanning websites
138 | - Use responsibly and ethically
139 | - This tool only analyzes HTTP headers and does not perform invasive testing
140 |
141 | ## Troubleshooting
142 |
143 | If you encounter issues:
144 |
145 | 1. Verify the target URL is accessible
146 | 2. Check for any network restrictions or firewalls
147 | 3. Ensure the reference JSON files are correctly formatted and loaded
148 | 4. Review server logs for detailed error messages
149 |
150 | ## Advanced Usage
151 |
152 | You can enhance this tool by:
153 |
154 | 1. Adding custom header security rules
155 | 2. Integrating with other security testing frameworks
156 | 3. Implementing severity ratings for findings
157 | 4. Creating detailed reports with remediation guidance
158 |
159 | ## Acknowledgments
160 |
161 | - OWASP Secure Headers Project: https://owasp.org/www-project-secure-headers/
162 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/shuffledns-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # shuffledns MCP
2 |
3 | > shuffledns MCP is a bridge that connects shuffledns, a fast and powerful DNS enumeration tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | shuffledns MCP enables seamless integration of shuffledns’s capabilities for DNS brute forcing, DNS resolving, and filtering into MCP-compatible applications and AI-driven workflow systems. This bridge allows you to efficiently discover subdomains, validate DNS records, and filter live hosts through a standardized protocol, making it easy to incorporate into automated reconnaissance pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Integration with shuffledns for fast DNS brute force and resolution
12 | - Support for different operational modes: bruteforce, resolve, and filter
13 | - Ability to use custom resolvers and wordlists
14 | - Optional rate limiting for fine-tuned performance
15 | - Simple configuration and setup
16 | - Standardized input/output handling compatible with other MCP tools
17 |
18 | ## Installation
19 |
20 | ### Prerequisites
21 |
22 | - Node.js (v16 or higher)
23 | - shuffledns and massdns installed on your system
24 | - MCP SDK
25 |
26 | ### Setup
27 |
28 | 1. Clone this repository:
29 | ```
30 | git clone https://github.com/cyproxio/mcp-for-security
31 | cd shuffledns-mcp
32 | ```
33 |
34 | 2. Install dependencies:
35 | ```
36 | npm install
37 | ```
38 |
39 | 3. Build the project:
40 | ```
41 | npm install && npm run build
42 | ```
43 |
44 | ## Usage
45 |
46 | ### Basic Configuration
47 |
48 | Configure the shuffledns MCP server in your MCP client configuration:
49 |
50 | ```json
51 | {
52 | "shuffledns": {
53 | "command": "node",
54 | "args": [
55 | "/path/to/shuffledns-mcp/build/index.js",
56 | "shuffledns",
57 | "massdns"
58 | ]
59 | }
60 | }
61 | ```
62 |
63 | ### Running shuffledns
64 |
65 | Once configured, you can run shuffledns through the MCP interface using the shuffledns tool:
66 |
67 | ```javascript
68 | // Example of calling shuffledns through MCP
69 | const result = await mcp.tools.invoke("shuffledns", {
70 | target: "example.com",
71 | resolver: "/path/to/resolvers.txt",
72 | mode: "bruteforce",
73 | wordlist: "/path/to/wordlist.txt",
74 | rateLimit: 1000 // optional
75 | });
76 |
77 | ```
78 |
79 | ## Parameters
80 |
81 | shuffledns MCP supports the following parameters:
82 | - target: Domain name to scan (e.g., example.com) (required)
83 | - resolver: Path to the resolver file containing DNS resolvers (required)
84 | - mode: The operation mode to use:
85 | - bruteforce: Perform a DNS brute force attack using a wordlist
86 | - resolve: Resolve a list of domain names
87 | - filter: Filter a list of subdomains to find active hosts
88 | - wordlist: Path to the wordlist for subdomain enumeration (required)
89 | - rateLimit: Number of DNS requests per second (optional)
90 |
91 | ## Examples
92 |
93 | ### Basic DNS Brute Forcing
94 |
95 | ```javascript
96 | const result = await mcp.tools.invoke("shuffledns", {
97 | target: "example.com",
98 | resolver: "/path/to/resolvers.txt",
99 | mode: "bruteforce",
100 | wordlist: "/path/to/wordlist.txt"
101 | });
102 | ```
103 |
104 | ### DNS Resolution of Existing Subdomains
105 |
106 | ```javascript
107 | const result = await mcp.tools.invoke("shuffledns", {
108 | target: "example.com",
109 | resolver: "/path/to/resolvers.txt",
110 | mode: "resolve",
111 | wordlist: "/path/to/existing-subdomains.txt"
112 | });
113 | ```
114 |
115 | ## Integration with AI Assistants
116 |
117 | shuffledns MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for subdomain discovery and DNS reconnaissance.
118 |
119 | Example conversation with an AI assistant:
120 |
121 | ```
122 | User: Find subdomains for example.com
123 | AI: I'll perform a DNS brute force on example.com to discover subdomains.
124 |
125 | [AI uses shuffledns MCP to scan the domain and returns the results]
126 |
127 | I found the following subdomains:
128 | - api.example.com
129 | - mail.example.com
130 | - dev.example.com
131 |
132 | Would you like me to check if they are active?
133 | ```
134 |
135 | ## Security Considerations
136 |
137 | - This tool is intended for authorized security testing and research purposes only.
138 | - Always obtain proper authorization before performing scans on external systems.
139 | - Be mindful of DNS resolver usage policies and avoid abuse.
140 | - Use responsible scanning practices and respect target systems.
141 |
142 |
143 | ## Troubleshooting
144 |
145 | If you encounter issues:
146 |
147 | 1. Ensure shuffledns is properly installed and accessible in the system PATH.
148 | 2. Ensure massdns is properly installed and accessible in the system PATH.
149 | 3. Check if the resolver file and wordlist paths are correct.
150 | 4. Review server logs for detailed error messages.
151 | 5. Adjust rate limits if DNS errors or throttling occur.
152 |
153 |
154 | ## Usage Tips
155 |
156 | - Use high-quality resolvers for faster and more reliable results.
157 | - Combine shuffledns output with HTTP probes (e.g., httpx) for comprehensive asset discovery.
158 | - Use filtering mode after brute forcing to identify only live subdomains.
159 | - Adjust rate limits based on your system and resolver capabilities to avoid packet loss.
160 |
161 | ## Acknowledgments
162 |
163 | - shuffledns Project: https://github.com/projectdiscovery/shuffledns
164 | - massdns Project: https://github.com/blechschmidt/massdns
165 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/waybackurls-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Waybackurls MCP
2 |
3 | > Waybackurls MCP is a bridge that connects Waybackurls, a tool for retrieving historical URLs from the Wayback Machine, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Waybackurls MCP enables seamless integration of Waybackurls' capability to discover historical endpoints into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage the Internet Archive's Wayback Machine to find forgotten API paths, old endpoints, and potentially vulnerable URLs through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Integration with Waybackurls to fetch historical URLs from the Wayback Machine
12 | - Option to include or exclude subdomains in the search
13 | - Simple configuration and setup
14 | - Easy integration with other MCP-compatible tools and systems
15 | - Standardized input/output handling
16 |
17 | ## Installation
18 |
19 | ### Prerequisites
20 |
21 | - Node.js (v16 or higher)
22 | - Waybackurls installed on your system
23 | - MCP SDK
24 |
25 | ### Setup
26 |
27 | 1. Clone this repository:
28 | ```
29 | git clone https://github.com/cyproxio/mcp-for-security
30 | cd waybackurls-mcp
31 | ```
32 |
33 | 2. Install dependencies:
34 | ```
35 | npm install
36 | ```
37 |
38 | 3. Build the project:
39 | ```
40 | npm install && npm run build
41 | ```
42 |
43 | ## Usage
44 |
45 | ### Basic Configuration
46 |
47 | Configure the Waybackurls MCP server in your MCP client configuration:
48 |
49 | ```json
50 | {
51 | "waybackurls": {
52 | "command": "node",
53 | "args": [
54 | "/path/to/waybackurls-mcp/build/index.js",
55 | "waybackurls"
56 | ]
57 | }
58 | }
59 | ```
60 |
61 | ### Running Waybackurls
62 |
63 | Once configured, you can run Waybackurls through the MCP interface using the `do-waybackurls` tool:
64 |
65 | ```javascript
66 | // Example of calling Waybackurls through MCP for a domain including subdomains
67 | const result = await mcp.tools.invoke("do-waybackurls", {
68 | target: "example.com",
69 | noSub: false
70 | });
71 |
72 | // Example of calling Waybackurls through MCP for a domain excluding subdomains
73 | const resultNoSubs = await mcp.tools.invoke("do-waybackurls", {
74 | target: "example.com",
75 | noSub: true
76 | });
77 | ```
78 |
79 | ## Parameters
80 |
81 | Waybackurls MCP supports the following parameters:
82 |
83 | - `target`: The domain to retrieve historical URLs for (required)
84 | - `noSub`: Boolean flag to control whether subdomains should be included (default: false)
85 |
86 | ## Examples
87 |
88 | ### Gather All Historical URLs
89 |
90 | ```javascript
91 | const result = await mcp.tools.invoke("do-waybackurls", {
92 | target: "example.com",
93 | noSub: false
94 | });
95 | ```
96 |
97 | ### Gather Historical URLs for Main Domain Only
98 |
99 | ```javascript
100 | const result = await mcp.tools.invoke("do-waybackurls", {
101 | target: "example.com",
102 | noSub: true
103 | });
104 | ```
105 |
106 | ### Process Results for Further Analysis
107 |
108 | ```javascript
109 | const result = await mcp.tools.invoke("do-waybackurls", {
110 | target: "example.com"
111 | });
112 |
113 | // Split the results into individual URLs
114 | const urls = result.content[0].text.trim().split('\n');
115 |
116 | // Filter for specific file types or patterns
117 | const jsFiles = urls.filter(url => url.endsWith('.js'));
118 | const apiEndpoints = urls.filter(url => url.includes('/api/'));
119 | ```
120 |
121 | ## Integration with AI Assistants
122 |
123 | Waybackurls MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing and reconnaissance tasks.
124 |
125 | Example conversation with an AI assistant:
126 |
127 | ```
128 | User: Find historical URLs for example.com
129 | AI: I'll retrieve historical URLs for example.com using the Wayback Machine.
130 |
131 | [AI uses Waybackurls MCP to fetch the URLs and returns the results]
132 |
133 | I found the following interesting historical endpoints for example.com:
134 | - Several old API endpoints: /api/v1/users, /api/v2/products
135 | - Previously accessible admin pages: /admin/dashboard, /admin/users
136 | - Backup files: /backup/db.sql, /backup/config.old
137 | ...
138 | ```
139 |
140 | ## Security Considerations
141 |
142 | - This tool is intended for legitimate security research and testing
143 | - Always obtain proper authorization before scanning websites
144 | - Use responsibly and ethically
145 | - The tool only retrieves information already publicly archived by the Internet Archive
146 |
147 | ## Troubleshooting
148 |
149 | If you encounter issues:
150 |
151 | 1. Verify Waybackurls is properly installed and accessible
152 | 2. Check the path to the Waybackurls executable in your configuration
153 | 3. Ensure proper permissions are set for execution
154 | 4. Review server logs for detailed error messages
155 | 5. Some domains may have limited or no history in the Wayback Machine
156 |
157 | ## Usage Tips
158 |
159 | - Combine Waybackurls results with other reconnaissance tools for more comprehensive target information
160 | - Filter results to focus on specific file types or directories of interest
161 | - Look for patterns in historical URLs that might indicate abandoned features or testing endpoints
162 | - Use the results to inform your security testing or bug bounty hunting
163 |
164 | ## Acknowledgments
165 |
166 | - Waybackurls Project: https://github.com/tomnomnom/waybackurls
167 | - Internet Archive Wayback Machine: https://archive.org/web/
168 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/amass-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Amass MCP
2 |
3 | > Amass MCP is a bridge that connects Amass, a powerful reconnaissance tool for network mapping and subdomain enumeration, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Amass MCP enables seamless integration of Amass's advanced reconnaissance capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage Amass's comprehensive subdomain discovery, intelligence gathering, and network mapping features through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Integration with Amass to perform advanced subdomain enumeration and reconnaissance
12 | - Support for both passive and active enumeration modes
13 | - Intelligence gathering capabilities with organization and WHOIS lookups
14 | - Brute force subdomain discovery with custom wordlist support
15 | - Simple configuration and setup
16 | - Easy integration with other MCP-compatible tools and systems
17 | - Standardized input/output handling
18 |
19 | ## Installation
20 |
21 | ### Prerequisites
22 |
23 | - Node.js (v16 or higher)
24 | - Amass installed on your system
25 | - MCP SDK
26 |
27 | ### Setup
28 |
29 | 1. Clone this repository:
30 | ```
31 | git clone https://github.com/cyproxio/mcp-for-security
32 | cd amass-mcp
33 | ```
34 |
35 | 2. Install dependencies:
36 | ```
37 | npm install
38 | ```
39 |
40 | 3. Build the project:
41 | ```
42 | npm install && npm run build
43 | ```
44 |
45 | ## Usage
46 |
47 | ### Basic Configuration
48 |
49 | Configure the Amass MCP server in your MCP client configuration:
50 |
51 | ```json
52 | {
53 | "amass": {
54 | "command": "node",
55 | "args": [
56 | "/path/to/amass-mcp/build/index.js",
57 | "amass"
58 | ]
59 | }
60 | }
61 | ```
62 |
63 | ### Running Amass
64 |
65 | Once configured, you can run Amass through the MCP interface using the `amass` tool with various subcommands:
66 |
67 | ```javascript
68 | // Example of calling Amass enum through MCP for passive reconnaissance
69 | const result = await mcp.tools.invoke("amass", {
70 | subcommand: "enum",
71 | domain: "example.com",
72 | enum_type: "passive"
73 | });
74 |
75 | // Example of calling Amass intel with organization search
76 | const intelResult = await mcp.tools.invoke("amass", {
77 | subcommand: "intel",
78 | intel_organization: "Example Corp",
79 | intel_whois: true
80 | });
81 | ```
82 |
83 | ## Parameters
84 |
85 | Amass MCP supports the following parameters:
86 |
87 | - `subcommand`: The Amass operation mode to use (required)
88 | - `enum`: Perform subdomain enumeration and network mapping
89 | - `intel`: Gather intelligence about target domains from various sources
90 |
91 | - For `enum` subcommand:
92 | - `domain`: Target domain to perform reconnaissance against (required)
93 | - `enum_type`: Enumeration approach type (optional)
94 | - `active`: Includes DNS resolution and potential network interactions with target
95 | - `passive`: Only uses information from third-party sources without direct target interaction
96 | - `enum_brute`: Whether to perform brute force subdomain discovery (optional)
97 | - `enum_brute_wordlist`: Path to custom wordlist file for brute force operations (optional)
98 |
99 | - For `intel` subcommand:
100 | - `domain`: Target domain to gather intelligence on (optional if organization is provided)
101 | - `intel_organization`: Organization name to search for (optional if domain is provided)
102 | - `intel_whois`: Whether to include WHOIS data in intelligence gathering (optional)
103 |
104 | ## Examples
105 |
106 | ### Passive Subdomain Enumeration
107 |
108 | ```javascript
109 | const result = await mcp.tools.invoke("amass", {
110 | subcommand: "enum",
111 | domain: "example.com",
112 | enum_type: "passive"
113 | });
114 | ```
115 |
116 | ### Active Subdomain Enumeration with Brute Force
117 |
118 | ```javascript
119 | const result = await mcp.tools.invoke("amass", {
120 | subcommand: "enum",
121 | domain: "example.com",
122 | enum_type: "active",
123 | enum_brute: true,
124 | enum_brute_wordlist: "/path/to/subdomains.txt"
125 | });
126 | ```
127 |
128 | ### Intelligence Gathering for an Organization
129 |
130 | ```javascript
131 | const result = await mcp.tools.invoke("amass", {
132 | subcommand: "intel",
133 | intel_organization: "Example Corp",
134 | intel_whois: true
135 | });
136 | ```
137 |
138 | ### Domain Intelligence with WHOIS
139 |
140 | ```javascript
141 | const result = await mcp.tools.invoke("amass", {
142 | subcommand: "intel",
143 | domain: "example.com",
144 | intel_whois: true
145 | });
146 | ```
147 |
148 | ## Integration with AI Assistants
149 |
150 | Amass MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing and reconnaissance tasks.
151 |
152 | Example conversation with an AI assistant:
153 |
154 | ```
155 | User: Perform reconnaissance on example.com
156 | AI: I'll run a passive subdomain enumeration for example.com using Amass.
157 |
158 | [AI uses Amass MCP to perform the enumeration and returns the results]
159 |
160 | I found the following subdomains for example.com:
161 | - api.example.com
162 | - mail.example.com
163 | - dev.example.com
164 | - admin.example.com
165 | - staging.example.com
166 | ...
167 |
168 | Would you like me to gather intelligence about the organization as well?
169 | ```
170 |
171 | ## Security Considerations
172 |
173 | - This tool is intended for legitimate security research and testing
174 | - Always obtain proper authorization before scanning websites
175 | - Active enumeration may generate significant traffic to the target
176 | - Use responsibly and ethically
177 | - Consider using passive mode for initial reconnaissance to minimize detection
178 |
179 | ## Troubleshooting
180 |
181 | If you encounter issues:
182 |
183 | 1. Verify Amass is properly installed and accessible in your PATH
184 | 2. Check the path to the Amass executable in your configuration
185 | 3. Ensure proper permissions are set for execution
186 | 4. Review server logs for detailed error messages
187 | 5. For large domains, consider increasing timeouts or memory limits
188 |
189 | ## Usage Tips
190 |
191 | - Combine Amass results with other reconnaissance tools for more comprehensive target information
192 | - Start with passive enumeration before using active techniques
193 | - Use custom wordlists tailored to the target's industry or technology stack
194 | - Filter results to focus on interesting subdomains that might indicate sensitive services
195 | - Use the intel subcommand to discover related domains and organizations
196 |
197 | ## Acknowledgments
198 |
199 | - Amass Project: https://github.com/OWASP/Amass
200 | - OWASP Foundation
201 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/gowitness-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # Gowitness MCP
2 |
3 | > Gowitness MCP is a bridge that connects gowitness, the powerful web screenshot and reconnaissance tool, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | Gowitness MCP enables seamless integration of gowitness's web screenshot and reconnaissance capabilities into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to leverage gowitness functionality through a standardized protocol, making it easier to incorporate web reconnaissance and visual documentation into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Full gowitness functionality exposed through MCP
12 | - Flexible storage options: save to disk or return binary data
13 | - Batch screenshot processing for multiple URLs
14 | - Support for both JPEG and PNG formats
15 | - Advanced Chrome browser configuration options
16 | - Database and JSON export capabilities
17 | - File management and binary data access tools
18 | - Easy integration with other MCP-compatible tools and systems
19 | - Standardized input/output handling
20 |
21 | ## Installation
22 |
23 | ### Prerequisites
24 |
25 | - Node.js (v16 or higher)
26 | - Go (for installing gowitness)
27 | - gowitness installed on your system
28 | - MCP SDK
29 |
30 | ### Setup
31 |
32 | 1. Clone this repository:
33 |
34 | ```bash
35 | git clone https://github.com/cyproxio/mcp-for-security
36 | cd gowitness-mcp
37 | ```
38 |
39 | 2. Install gowitness:
40 |
41 | ```bash
42 | go install github.com/sensepost/gowitness@latest
43 | ```
44 |
45 | 3. Install dependencies and build:
46 |
47 | ```bash
48 | npm install && npm run build
49 | ```
50 |
51 | 4. Configure for Claude (automated):
52 |
53 | ```bash
54 | # Windows PowerShell
55 | .\setup-mcp.ps1
56 |
57 | # Unix/Linux/macOS
58 | ./build.sh
59 | ```
60 |
61 |
62 | ## Usage
63 |
64 | ### Basic Configuration
65 |
66 | Configure the Gowitness MCP server in your MCP client configuration:
67 |
68 | ```json
69 | {
70 | "mcpServers": {
71 | "gowitness": {
72 | "command": "node",
73 | "args": [
74 | "/path/to/gowitness-mcp/build/index.js",
75 | "gowitness"
76 | ],
77 | "env": {
78 | "PATH": "${PATH}"
79 | }
80 | }
81 | }
82 | }
83 | ```
84 |
85 | ### Taking Screenshots
86 |
87 | Once configured, you can capture web screenshots through the MCP interface using the available tools:
88 |
89 | #### Single Screenshot (Binary Return)
90 |
91 | ```javascript
92 | // Screenshot without saving to disk - returns binary data
93 | const result = await mcp.tools.invoke("gowitness-screenshot", {
94 | url: "https://example.com"
95 | });
96 | ```
97 |
98 | #### Single Screenshot (Save to Directory)
99 |
100 | ```javascript
101 | // Screenshot with file persistence
102 | const result = await mcp.tools.invoke("gowitness-screenshot", {
103 | url: "https://example.com",
104 | screenshot_path: "./my-screenshots"
105 | });
106 | ```
107 |
108 | #### Batch Screenshots
109 |
110 | ```javascript
111 | // Multiple URLs at once
112 | const result = await mcp.tools.invoke("gowitness-batch-screenshot", {
113 | urls: [
114 | "https://example.com",
115 | "https://google.com",
116 | "https://github.com"
117 | ],
118 | screenshot_path: "./batch-screenshots"
119 | });
120 | ```
121 |
122 | ### Available Tools
123 |
124 | - **`gowitness-screenshot`** - Capture single URL screenshots with extensive options
125 | - **`gowitness-batch-screenshot`** - Process multiple URLs efficiently
126 | - **`gowitness-list-screenshots`** - List saved screenshot files with metadata
127 | - **`gowitness-read-binary`** - Read screenshot files as binary data
128 | - **`gowitness-report`** - Generate reports from captured data
129 |
130 | ### Advanced Options
131 |
132 | Gowitness MCP supports all standard gowitness parameters including:
133 |
134 | - **Browser Settings**: Window dimensions, user agents, proxy configuration
135 | - **Capture Options**: Full-page screenshots, custom delays, timeouts
136 | - **Output Formats**: JPEG/PNG format selection
137 | - **Data Persistence**: Database logging, JSON export
138 | - **Performance**: Concurrent threading for batch operations
139 |
140 | See the [gowitness documentation](https://github.com/sensepost/gowitness) for complete parameter details.
141 |
142 | ## Integration with AI Assistants
143 |
144 | Gowitness MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for web reconnaissance and documentation tasks.
145 |
146 | Example conversation with an AI assistant:
147 |
148 | ```
149 | User: Take screenshots of the main pages on example.com for documentation
150 | AI: I'll capture screenshots of the main pages on example.com for you.
151 |
152 | [AI uses Gowitness MCP to capture the screenshots]
153 |
154 | I've successfully captured screenshots of:
155 | - Homepage (example.com) - 1.2MB PNG
156 | - About page (example.com/about) - 890KB PNG
157 | - Contact page (example.com/contact) - 756KB PNG
158 |
159 | All screenshots have been saved to ./documentation-screenshots/
160 | ```
161 |
162 | ```
163 | User: I need to document a suspicious website without saving files locally
164 | AI: I'll capture the website and return the image data directly without saving files.
165 |
166 | [AI uses binary return mode]
167 |
168 | I've captured the website screenshot and returned it as binary data. The image shows...
169 | [Analysis of the screenshot content]
170 | ```
171 |
172 | ## Storage Behavior
173 |
174 | ### Binary Mode (No Directory Specified)
175 |
176 | - Returns screenshot as base64-encoded binary data
177 | - Temporary files are automatically cleaned up
178 | - Perfect for inline analysis and processing
179 |
180 | ### File Mode (Directory Specified)
181 |
182 | - Saves screenshots to specified directory
183 | - Files persist for later access and analysis
184 | - Can optionally also return binary data
185 |
186 | ### Batch Mode
187 |
188 | - Always saves to specified directory for organization
189 | - Efficient concurrent processing of multiple URLs
190 | - Comprehensive progress reporting
191 |
192 | ## Troubleshooting
193 |
194 | If you encounter issues:
195 |
196 | 1. **"spawn gowitness ENOENT"**
197 |
198 | - Verify gowitness is installed: `gowitness --help`
199 | - Ensure gowitness is in your PATH
200 | - Try using absolute path in MCP configuration
201 | 2. **Screenshot capture failures**
202 |
203 | - Check URL accessibility and network connectivity
204 | - Verify target website allows automated access
205 | - Try increasing timeout and delay parameters
206 | 3. **Permission errors**
207 |
208 | - Ensure write permissions for screenshot directories
209 | - Check that Chrome/Chromium can be accessed by gowitness
210 | 4. **Binary return issues**
211 |
212 | - Use the file mode first to verify screenshots work
213 | - Then use list and read tools to access binary data
214 | - Check available files with `gowitness-list-screenshots`
215 |
216 | ## Acknowledgments
217 |
218 | - Gowitness Project: https://github.com/sensepost/gowitness
219 | - Model Context Protocol: https://github.com/modelcontextprotocol
220 | - SensePost team for creating the excellent gowitness tool
```
--------------------------------------------------------------------------------
/httpx-mcp/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # httpx MCP
2 |
3 | > httpx MCP is a bridge that connects httpx, a fast and multi-purpose HTTP toolkit for probing web servers, with the Model Context Protocol (MCP) ecosystem.
4 |
5 | ## Overview
6 |
7 | httpx MCP enables seamless integration of httpx's capabilities to scan and analyze HTTP/HTTPS services into MCP-compatible applications and AI-powered workflow systems. This bridge allows you to detect active web services, extract valuable information about web servers, and identify technologies in use through a standardized protocol, making it easier to incorporate into automated security testing pipelines or AI assistant capabilities.
8 |
9 | ## Features
10 |
11 | - Integration with httpx to scan for active HTTP and HTTPS services
12 | - Support for multiple target domains in a single scan
13 | - Customizable port scanning
14 | - Extensive probing options for detailed web server analysis
15 | - Technology detection based on the Wappalyzer dataset
16 | - Response analysis including status codes, headers, and content
17 | - Simple configuration and setup
18 | - Easy integration with other MCP-compatible tools and systems
19 | - Standardized input/output handling
20 |
21 | ## Installation
22 |
23 | ### Prerequisites
24 |
25 | - Node.js (v16 or higher)
26 | - httpx installed on your system
27 | - MCP SDK
28 |
29 | ### Setup
30 |
31 | 1. Clone this repository:
32 | ```
33 | git clone https://github.com/cyproxio/mcp-for-security
34 | cd httpx-mcp
35 | ```
36 |
37 | 2. Install dependencies:
38 | ```
39 | npm install
40 | ```
41 |
42 | 3. Build the project:
43 | ```
44 | npm install && npm run build
45 | ```
46 |
47 | ## Usage
48 |
49 | ### Basic Configuration
50 |
51 | Configure the httpx MCP server in your MCP client configuration:
52 |
53 | ```json
54 | {
55 | "httpx": {
56 | "command": "node",
57 | "args": [
58 | "/path/to/httpx-mcp/build/index.js",
59 | "httpx"
60 | ]
61 | }
62 | }
63 | ```
64 |
65 | ### Running httpx
66 |
67 | Once configured, you can run httpx through the MCP interface using the `httpx` tool:
68 |
69 | ```javascript
70 | // Example of calling httpx through MCP for a single domain
71 | const result = await mcp.tools.invoke("httpx", {
72 | target: ["example.com"]
73 | });
74 |
75 | // Example of calling httpx with multiple targets and probes
76 | const detailedResult = await mcp.tools.invoke("httpx", {
77 | target: ["example.com", "example.org", "example.net"],
78 | ports: ["80", "443", "8080", "8443"],
79 | probes: ["title", "status-code", "tech-detect", "web-server"]
80 | });
81 | ```
82 |
83 | ## Parameters
84 |
85 | httpx MCP supports the following parameters:
86 |
87 | - `target`: A list of domain names to scan for HTTP and HTTPS services (required)
88 | - `ports`: Custom ports to scan (optional, defaults to standard HTTP/HTTPS ports)
89 | - `probes`: List of probe options to extract specific information (optional)
90 |
91 | ### Available Probe Options
92 |
93 | - `status-code`: Display response status-code
94 | - `content-length`: Display response content-length
95 | - `content-type`: Display response content-type
96 | - `location`: Display response redirect location
97 | - `favicon`: Display mmh3 hash for '/favicon.ico' file
98 | - `hash`: Display response body hash (supported: md5, mmh3, simhash, sha1, sha256, sha512)
99 | - `jarm`: Display jarm fingerprint hash
100 | - `response-time`: Display response time
101 | - `line-count`: Display response body line count
102 | - `word-count`: Display response body word count
103 | - `title`: Display page title
104 | - `body-preview`: Display first N characters of response body (default 100)
105 | - `web-server`: Display server name
106 | - `tech-detect`: Display technology in use based on wappalyzer dataset
107 | - `method`: Display HTTP request method
108 | - `websocket`: Display server using websocket
109 | - `ip`: Display host IP
110 | - `cname`: Display host CNAME
111 | - `extract-fqdn`: Get domain and subdomains from response body and header
112 | - `asn`: Display host ASN information
113 | - `cdn`: Display CDN/WAF in use (default true)
114 | - `probe`: Display probe status
115 |
116 | ## Examples
117 |
118 | ### Basic Scan of Multiple Domains
119 |
120 | ```javascript
121 | const result = await mcp.tools.invoke("httpx", {
122 | target: ["example.com", "example.org", "example.net"]
123 | });
124 | ```
125 |
126 | ### Scan with Custom Ports
127 |
128 | ```javascript
129 | const result = await mcp.tools.invoke("httpx", {
130 | target: ["example.com"],
131 | ports: ["80", "443", "8080", "8443"]
132 | });
133 | ```
134 |
135 | ### Comprehensive Web Technology Analysis
136 |
137 | ```javascript
138 | const result = await mcp.tools.invoke("httpx", {
139 | target: ["example.com"],
140 | probes: ["tech-detect", "web-server", "title", "status-code", "content-type"]
141 | });
142 | ```
143 |
144 | ### Extract Subdomains from Response
145 |
146 | ```javascript
147 | const result = await mcp.tools.invoke("httpx", {
148 | target: ["example.com"],
149 | probes: ["extract-fqdn", "status-code"]
150 | });
151 | ```
152 |
153 | ## Integration with AI Assistants
154 |
155 | httpx MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for web server discovery and analysis.
156 |
157 | Example conversation with an AI assistant:
158 |
159 | ```
160 | User: Can you check what web technologies are used by example.com?
161 | AI: I'll scan example.com to identify the web technologies in use.
162 |
163 | [AI uses httpx MCP to scan the domain and returns the results]
164 |
165 | I found the following technologies on example.com:
166 | - Web Server: nginx/1.18.0
167 | - Technologies: Bootstrap, jQuery, Google Analytics
168 | - Status Code: 200 OK
169 | - Title: Example Domain
170 |
171 | Would you like me to analyze any other aspects of this website?
172 | ```
173 |
174 | ## Security Considerations
175 |
176 | - This tool is intended for legitimate security research and testing
177 | - Always obtain proper authorization before scanning websites
178 | - Respect rate limits to avoid overwhelming target servers
179 | - Use responsibly and ethically
180 | - The tool only performs passive analysis of publicly available information
181 |
182 | ## Troubleshooting
183 |
184 | If you encounter issues:
185 |
186 | 1. Verify httpx is properly installed and accessible
187 | 2. Check the path to the httpx executable in your configuration
188 | 3. Ensure proper permissions are set for execution
189 | 4. Review server logs for detailed error messages
190 | 5. For large scans, consider increasing timeouts or memory limits
191 |
192 | ## Usage Tips
193 |
194 | - Combine httpx results with other reconnaissance tools for more comprehensive target information
195 | - Use the tech-detect probe to quickly identify technologies that might have known vulnerabilities
196 | - The extract-fqdn probe can help discover additional subdomains not found through other methods
197 | - Use body-preview to get a quick glimpse of the response content without downloading everything
198 | - The CDN detection can help identify which targets might be protected by WAFs
199 |
200 | ## Acknowledgments
201 |
202 | - httpx Project: https://github.com/projectdiscovery/httpx
203 | - Model Context Protocol: https://github.com/modelcontextprotocol
```
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
```markdown
1 | # MCP for Security
2 |
3 | [](LICENSE)
4 | [](https://github.com/cyproxio/mcp-for-security/stargazers)
5 | [](https://github.com/cyproxio/mcp-for-security/releases)
6 | ---
7 |
8 | <img src="https://avatars.githubusercontent.com/u/89649708?s=48&v=4" width="40" align="left" />
9 |
10 | **About Cyprox — The Future of AI-Driven Cybersecurity** <br/></br>
11 |
12 |
13 | **Cyprox** is pioneering the future of cybersecurity by combining artificial intelligence and security tools to empower organizations with next-level threat detection and automated response.
14 |
15 | > *"The Future of Cybersecurity Humans and AI, Working Together..."*
16 |
17 | ### Cyprox
18 |
19 | - 🚀 **AI Driven Solutions:** Cybersecurity solutions using Agentic-AI systems with an AI-driven approach
20 | - 🌐 **Community-Driven:** Open-source projects fostering collaboration and rapid evolution.
21 | - ⚡ **Speed & Precision:** Automated threat detection that reduces human latency.
22 | - 🔒 **Secure & Transparent:** Trustworthy platform built with open standards.
23 |
24 | Explore more at [https://cyprox.io](https://cyprox.io)
25 |
26 | ---
27 |
28 | ## 🚀 Project Overview
29 |
30 | **MCP for Security** repository contains Model Context Protocol (MCP) server implementations for various security testing tools, making them accessible through a standardized interface.
31 |
32 | ---
33 |
34 | ## 🌐 Installation
35 |
36 | ### Docker
37 |
38 | You can use all MCP servers through Docker using the cyprox/mcp-for-security Docker image. It can also be used from any MCP client with Docker support, such as the Cyprox platform.
39 | Visit [Cyprox](https://cyprox.io) for more information.
40 |
41 | ### Manuel
42 | Since each MCP server may require different dependencies, the `start.sh` bash script provides a general setup mechanism. Nonetheless, users should always refer to the installation instructions specific to the corresponding MCP server to ensure proper setup.
43 |
44 | ---
45 |
46 |
47 | ## Available Tools
48 |
49 | | Tool | Description | Detailed Documentation |
50 | |------|-------------|------------------------|
51 | | Amass | Advanced subdomain enumeration and reconnaissance tool | [Amass MCP Documentation](./amass-mcp) |
52 | | Alterx | Pattern-based wordlist generator for subdomain discovery | [Alterx MCP Documentation](./alterx-mcp/) |
53 | | Arjun | Run Arjun to discover hidden HTTP parameters | [Arjun MCP Documentation](./arjun-mcp) |
54 | | Assetfinder | Passive subdomain discovery tool based on Tomnomnom’s Assetfinder | [Assetfinder MCP Documentation](./assetfinder-mcp) |
55 | | Cero | Certificate-based subdomain enumeration tool leveraging TLS handshakes to extract domain names from certificate fields like SAN | [Cero MCP Documentation](./cero-mcp) |
56 | | Certificate Search (crt.sh) | Subdomain discovery tool using SSL certificate logs | [Certificate Search MCP Documentation](./crtsh-mcp/) |
57 | | FFUF | Web content fuzzing tool for discovering hidden files and directories | [FFUF MCP Documentation](./ffuf-mcp/) |
58 | | Gowitness | Web screenshot and reconnaissance tool for capturing and analyzing web pages | [Gowitness MCP Documentation](./gowitness-mcp/) |
59 | | HTTP Headers Security | Analyzer for HTTP security headers against OWASP standards | [HTTP Headers MCP Documentation](./http-headers-security-mcp/) |
60 | | httpx | Fast and multi-purpose HTTP toolkit for port scanning. | [httpx MCP Documentation](./httpx-mcp) |
61 | | Katana | Fast and flexible web crawler with JS parsing and hybrid crawling support | [Katana MCP Documentation](./katana-mcp/) |
62 | | Masscan | Fast port scanner for large-scale network discovery | [Masscan MCP Documentation](./masscan-mcp/) |
63 | | MobSF | Mobile security framework for analyzing mobile applications | [MobSF MCP Documentation](./mobsf-mcp/) |
64 | | Nmap | Comprehensive network scanning tool for service and vulnerability discovery | [Nmap MCP Documentation](./nmap-mcp/) |
65 | | Nuclei | Vulnerability scanner using custom templates | [Nuclei MCP Documentation](./nuclei-mcp/) |
66 | | Scout Suite | Cloud security auditing tool for assessing configurations across multiple services | [Scout Suite MCP Documentation](./scoutsuite-mcp/) |
67 | | SSLScan | SSL/TLS configuration analyzer for security assessment | [SSLScan MCP Documentation](./sslscan-mcp/) |
68 | | shuffledns | High-speed and customizable DNS brute-forcing and resolution tool | [shuffledns MCP Documentation](./shuffledns-mcp) |
69 | | Smuggler | Advanced tool for detecting HTTP Request Smuggling vulnerabilities | [Smuggler MCP Documentation](./smuggler-mcp) |
70 | | SQLmap | Advanced SQL injection detection and exploitation tool | [SQLmap MCP Documentation](./sqlmap-mcp/) |
71 | | Waybackurls | Tool for retrieving historical URLs from the Wayback Machine | [Waybackurls MCP Documentation](./waybackurls-mcp/) |
72 | | WPScan | WordPress vulnerability scanner for detecting plugins, themes, and configuration issues | [WPScan MCP Documentation](./wpscan-mcp/) |
73 |
74 | ## Quick Reference
75 |
76 | ### Alterx MCP
77 | Generates custom wordlists for subdomain discovery using pattern-based permutations.
78 |
79 | ### Amass MCP
80 | Advanced reconnaissance tool for subdomain enumeration and intelligence gathering with both passive and active modes.
81 |
82 | ### arjun MCP
83 | Discovers hidden HTTP parameters on web applications by scanning URLs, supporting custom wordlists, multiple methods, and adjustable scanning speeds.
84 |
85 | ### Assetfinder MCP
86 | Discovers subdomains related to a given domain using passive enumeration techniques. Integrates Tomnomnom’s Assetfinder into the MCP ecosystem for fast and reliable reconnaissance.
87 |
88 | ### Cero MCP Server
89 | Certificate-based subdomain discovery tool that extracts domain names from TLS certificates for reconnaissance and infrastructure mapping.
90 |
91 | ### Certificate Search (crt.sh) MCP
92 | Discovers subdomains by querying SSL certificate transparency logs without active scanning.
93 |
94 | ### FFUF MCP Server
95 | URL-based fuzzing tool with support for all FFUF command line arguments.
96 |
97 | ### Gowitness MCP Server
98 | Web screenshot and reconnaissance tool that captures screenshots of web pages, analyzes HTTP responses, and provides visual reconnaissance capabilities for security assessments and web application testing.
99 |
100 | ### HTTP Headers Security MCP
101 | Analyzes HTTP response headers against OWASP security standards with recommendations.
102 |
103 | ### httpx MCP
104 | Performs high-speed probing of discovered subdomains to validate alive hosts, fetch response details, and enrich reconnaissance data without heavy scanning.
105 |
106 | ### Katana MCP
107 | Performs fast and customizable web crawling to discover endpoints, scripts, and hidden paths. Supports JavaScript parsing, depth control, and hybrid crawling with headless browsers to enrich reconnaissance and automation workflows.
108 |
109 | ### Masscan MCP Server
110 | Fast port scanning tool for target-based port discovery across networks.
111 |
112 | ### MobSF MCP Server
113 | Mobile application security testing framework for Android, iOS, and Windows applications.
114 |
115 | ### Nmap MCP Server
116 | Full-featured network scanner with detailed service fingerprinting and vulnerability detection.
117 |
118 | ### Nuclei MCP Server
119 | Template-based vulnerability scanner with an extensive library of security checks.
120 |
121 | ### Scout Suite MCP Server
122 | Performs a multi-service cloud security audit by analyzing cloud configurations and highlighting potential misconfigurations and risks based on best practices.
123 |
124 | ### shuffledns MCP
125 | High-speed DNS brute-forcing and mass subdomain resolution tool to quickly discover valid subdomains using custom resolvers and wordlists.
126 |
127 | ### smuggler MCP
128 | HTTP Request Smuggling detection tool that identifies desynchronization vulnerabilities between front-end and back-end servers.
129 |
130 | ### SQLmap MCP Server
131 | SQL injection testing tool with comprehensive capabilities for vulnerability discovery.
132 |
133 | ### SSLScan MCP Server
134 | SSL/TLS configuration analyzer for identifying weak ciphers and security misconfigurations.
135 |
136 | ### Waybackurls MCP
137 | Retrieves historical URLs from the Wayback Machine to discover forgotten endpoints.
138 |
139 | ### WPScan MCP
140 | WordPress vulnerability scanner for detecting outdated plugins, themes, and common misconfigurations.
141 |
142 |
143 | ## TO-DO Tools
144 | - commix
145 | - Corsy
146 | - CrackMapExec
147 | - crlfuzz
148 | - dalfox
149 | - dnsrecon
150 | - feroxbuster
151 | - gau
152 | - getJS
153 | - github-endpoints
154 | - github-subdomains
155 | - gobuster
156 | - gospider
157 | - hakrawler
158 | - kiterunner
159 | - medusa
160 | - naabu
161 | - ParamSpider
162 | - puredns
163 | - s3scanner
164 | - tlsx
165 | - wafw00f
166 | - webscreenshot
167 | - wpscan
168 | - ...
169 |
170 | ## Development
171 |
172 | The project uses TypeScript and the Model Context Protocol SDK. To contribute:
173 |
174 | 1. Fork the repository
175 | 2. Create a feature branch
176 | 3. Make your changes
177 | 4. Submit a pull request
178 |
179 | ## Installation
180 |
181 | For installation instructions for each tool, please refer to the individual documentation linked in the table above.
182 |
183 | ## Usage
184 |
185 | Each tool has specific parameters and usage instructions. For detailed information, see the documentation for the specific tool you want to use.
186 |
187 |
```
--------------------------------------------------------------------------------
/mobsf-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | npm install && npm run build
```
--------------------------------------------------------------------------------
/shuffledns-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | npm install && npm run build
```
--------------------------------------------------------------------------------
/sslscan-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | npm install && npm run build
```
--------------------------------------------------------------------------------
/smuggler-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "commonjs",
5 | "outDir": "./build",
6 | "strict": true,
7 | "esModuleInterop": true,
8 | "skipLibCheck": true,
9 | "forceConsistentCasingInFileNames": true
10 | },
11 | "include": ["src/**/*"],
12 | "exclude": ["node_modules", "build"]
13 | }
```
--------------------------------------------------------------------------------
/ffuf-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "ffuf-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "devDependencies": {
13 | "@types/node": "^22.14.0",
14 | "typescript": "^5.8.2"
15 | },
16 | "dependencies": {
17 | "@modelcontextprotocol/sdk": "^1.8.0",
18 | "zod": "^3.24.2"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/nmap-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "nmap-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.0",
18 | "typescript": "^5.8.2"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/alterx-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "alterx-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.9.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.1",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/amass-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "amass-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.0",
14 | "zod": "^3.24.3"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.15.3",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/sqlmap-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "sqlmap-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.0",
18 | "typescript": "^5.8.2"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/arjun-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "arjun-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.1",
14 | "zod": "^3.24.4"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.15.17",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/masscan-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "masscan-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.0",
18 | "typescript": "^5.8.2"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/sslscan-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "sslscan-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.0",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/wpscan-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "wpscan-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.12.2",
14 | "zod": "^3.25.64"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^24.0.1",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/waybackurls-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "waybackurls-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.9.0",
14 | "zod": "^3.24.2"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.14.0",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/gowitness-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "gowitness-mcp",
3 | "version": "1.0.0",
4 | "type": "module",
5 | "scripts": {
6 | "build": "tsc",
7 | "dev": "tsx src/index.ts",
8 | "start": "node build/index.js"
9 | },
10 | "dependencies": {
11 | "@modelcontextprotocol/sdk": "^1.17.2",
12 | "zod": "^3.22.0"
13 | },
14 | "devDependencies": {
15 | "@types/node": "^20.0.0",
16 | "tsx": "^4.0.0",
17 | "typescript": "^5.0.0"
18 | }
19 | }
20 |
```
--------------------------------------------------------------------------------
/mobsf-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "mobsf-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "axios": "^1.8.4",
15 | "zod": "^3.24.2"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.14.0",
19 | "typescript": "^5.8.2"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/commix-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "commix-mcp",
3 | "version": "1.0.0",
4 | "description": "",
5 | "main": "index.js",
6 | "scripts": {
7 | "build": "tsc"
8 | },
9 | "keywords": [],
10 | "author": "",
11 | "license": "ISC",
12 | "type": "commonjs",
13 | "dependencies": {
14 | "@modelcontextprotocol/sdk": "^1.15.1",
15 | "zod": "^3.25.76"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^24.0.13",
19 | "typescript": "^5.8.3"
20 | }
21 | }
```
--------------------------------------------------------------------------------
/httpx-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "httpx-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.0",
14 | "node-pty": "^1.0.0",
15 | "zod": "^3.24.3"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.15.3",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/nuclei-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "nuclei-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.8.0",
14 | "node-pty": "^1.0.0",
15 | "zod": "^3.24.2"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.14.0",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/katana-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "katana-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.4",
14 | "node-pty": "^1.0.0",
15 | "zod": "^3.25.3"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.15.19",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/scoutsuite-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "scoutsuite-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.4",
14 | "node-pty": "^1.0.0",
15 | "zod": "^3.25.7"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.15.20",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/shuffledns-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "shuffledns-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "devDependencies": {
13 | "@types/node": "^22.15.12",
14 | "typescript": "^5.8.3"
15 | },
16 | "dependencies": {
17 | "@modelcontextprotocol/sdk": "^1.11.0",
18 | "node-pty": "^1.0.0",
19 | "zod": "^3.24.4"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/assetfinder-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "assetfinder-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.4",
14 | "node-pty": "^1.0.0",
15 | "zod": "^3.25.7"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.15.19",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/http-headers-security-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "http-headers-security-mcp",
3 | "version": "1.0.0",
4 | "main": "index.js",
5 | "scripts": {
6 | "build": "tsc"
7 | },
8 | "keywords": [],
9 | "author": "",
10 | "license": "ISC",
11 | "description": "",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.9.0",
14 | "axios": "^1.8.4",
15 | "zod": "^3.24.2"
16 | },
17 | "devDependencies": {
18 | "@types/node": "^22.14.0",
19 | "typescript": "^5.8.3"
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/smuggler-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "smuggler-mcp",
3 | "version": "1.0.0",
4 | "description": "MCP wrapper for HTTP Request Smuggling testing tool",
5 | "main": "build/index.js",
6 | "scripts": {
7 | "build": "tsc",
8 | "start": "node build/index.js"
9 | },
10 | "dependencies": {
11 | "@modelcontextprotocol/sdk": "^1.11.2",
12 | "zod": "^3.21.4"
13 | },
14 | "devDependencies": {
15 | "typescript": "^5.0.4",
16 | "@types/node": "^18.11.9"
17 | }
18 | }
```
--------------------------------------------------------------------------------
/cero/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "cero",
3 | "version": "1.0.0",
4 | "description": "",
5 | "main": "index.js",
6 | "scripts": {
7 | "build": "tsc"
8 | },
9 | "keywords": [],
10 | "author": "",
11 | "license": "ISC",
12 | "type": "commonjs",
13 | "dependencies": {
14 | "@modelcontextprotocol/sdk": "^1.15.1",
15 | "node-pty": "^1.0.0",
16 | "zod": "^3.25.76"
17 | },
18 | "devDependencies": {
19 | "@types/node": "^24.0.12",
20 | "typescript": "^5.8.3"
21 | }
22 | }
23 |
```
--------------------------------------------------------------------------------
/alterx-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/amass-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/crtsh-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/ffuf-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/httpx-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/masscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/mobsf-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/nmap-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/nuclei-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/shuffledns-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/sqlmap-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/sslscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/waybackurls-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
```
--------------------------------------------------------------------------------
/arjun-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/assetfinder-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/cero/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/commix-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/katana-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/scoutsuite-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/wpscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true
12 | },
13 | "include": [
14 | "src/**/*"
15 | ],
16 | "exclude": [
17 | "node_modules"
18 | ]
19 | }
20 |
```
--------------------------------------------------------------------------------
/gowitness-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "ESNext",
5 | "moduleResolution": "node",
6 | "esModuleInterop": true,
7 | "allowSyntheticDefaultImports": true,
8 | "strict": true,
9 | "skipLibCheck": true,
10 | "forceConsistentCasingInFileNames": true,
11 | "outDir": "./build",
12 | "rootDir": "./src",
13 | "declaration": true,
14 | "declarationMap": true,
15 | "sourceMap": true
16 | },
17 | "include": ["src/**/*"],
18 | "exclude": ["node_modules", "build"]
19 | }
```
--------------------------------------------------------------------------------
/crtsh-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | SERVICE_PATH=$(pwd)
9 | INDEX_PATH="$SERVICE_PATH/build/index.js"
10 | COMMAND_NAME=$(basename "$SERVICE_PATH")
11 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
12 |
13 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
14 |
15 | jq --arg cmd "$COMMAND_NAME" \
16 | --arg node_path "$INDEX_PATH" \
17 | '.[$cmd] = { "command": "node", "args": [$node_path] }' \
18 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/http-headers-security-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | SERVICE_PATH=$(pwd)
9 | INDEX_PATH="$SERVICE_PATH/build/index.js"
10 | COMMAND_NAME=$(basename "$SERVICE_PATH")
11 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
12 |
13 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
14 |
15 | jq --arg cmd "$COMMAND_NAME" \
16 | --arg node_path "$INDEX_PATH" \
17 | '.[$cmd] = { "command": "node", "args": [$node_path] }' \
18 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/http-headers-security-mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "Node16",
5 | "moduleResolution": "Node16",
6 | "outDir": "./build",
7 | "rootDir": "./src",
8 | "strict": true,
9 | "esModuleInterop": true,
10 | "skipLibCheck": true,
11 | "forceConsistentCasingInFileNames": true,
12 | "resolveJsonModule": true
13 | },
14 | "include": [
15 | "src/**/*",
16 | "src/owasp_headers_remove.json",
17 | "src/owasp_headers_add.json"
18 | ],
19 | "exclude": [
20 | "node_modules"
21 | ]
22 |
23 | }
```
--------------------------------------------------------------------------------
/crtsh-mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "crtsh-mcp",
3 | "version": "1.0.0",
4 | "description": "> Certificate Search MCP is a bridge that connects crt.sh, a tool for discovering subdomains using SSL certificate logs, with the Model Context Protocol (MCP) ecosystem.",
5 | "main": "index.js",
6 | "scripts": {
7 | "build": "tsc"
8 | },
9 | "keywords": [],
10 | "author": "",
11 | "license": "ISC",
12 | "dependencies": {
13 | "@modelcontextprotocol/sdk": "^1.11.0",
14 | "zod": "^3.24.3"
15 | },
16 | "devDependencies": {
17 | "@types/node": "^22.15.3",
18 | "typescript": "^5.8.3"
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/nmap-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | SERVICE_PATH=$(pwd)
9 | INDEX_PATH="$SERVICE_PATH/build/index.js"
10 | NMAP_PATH=$(which nmap)
11 | COMMAND_NAME=$(basename "$SERVICE_PATH")
12 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
13 |
14 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
15 |
16 | jq --arg cmd "$COMMAND_NAME" \
17 | --arg node_path "$INDEX_PATH" \
18 | --arg bin_path "$NMAP_PATH" \
19 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
20 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/masscan-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | SERVICE_PATH=$(pwd)
9 | INDEX_PATH="$SERVICE_PATH/build/index.js"
10 | MASSCAN_PATH=$(which masscan)
11 | COMMAND_NAME=$(basename "$SERVICE_PATH")
12 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
13 |
14 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
15 |
16 | jq --arg cmd "$COMMAND_NAME" \
17 | --arg node_path "$INDEX_PATH" \
18 | --arg bin_path "$MASSCAN_PATH" \
19 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
20 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/ffuf-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/ffuf/ffuf@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | FFUF_PATH=$(which ffuf)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$FFUF_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/cero/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/glebarez/cero@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | CERO_PATH=$(which cero)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$CERO_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/scoutsuite-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | source /opt/venv/bin/activate
9 | pip install scoutsuite
10 |
11 | SERVICE_PATH=$(pwd)
12 | INDEX_PATH="$SERVICE_PATH/build/index.js"
13 | SCOUT_PATH=$(which scout)
14 | COMMAND_NAME=$(basename "$SERVICE_PATH")
15 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
16 |
17 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
18 |
19 | jq --arg cmd "$COMMAND_NAME" \
20 | --arg node_path "$INDEX_PATH" \
21 | --arg bin_path "$SCOUT_PATH" \
22 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
23 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/amass-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/owasp-amass/amass/v4/...@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | AMASS_PATH=$(which amass)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg amass_path "$AMASS_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $amass_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/wpscan-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | # Ensure wpscan is installed
9 | [ -x "$(which wpscan)" ] || gem install wpscan >/dev/null
10 |
11 | SERVICE_PATH=$(pwd)
12 | INDEX_PATH="$SERVICE_PATH/build/index.js"
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg index_path "$INDEX_PATH" \
20 | --arg bin_name "wpscan" \
21 | '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/gowitness-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/sensepost/gowitness@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | GOWITNESS_PATH=$(which gowitness)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$GOWITNESS_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/httpx-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/projectdiscovery/httpx/cmd/httpx@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | HTTPX_PATH=$(which httpx)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$HTTPX_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/katana-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/projectdiscovery/katana/cmd/katana@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | KATANA_PATH=$(which katana)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$KATANA_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/assetfinder-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/tomnomnom/assetfinder@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | ASSETFINDER_PATH=$(which assetfinder)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$ASSETFINDER_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/nuclei-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
9 |
10 | SERVICE_PATH=$(pwd)
11 | INDEX_PATH="$SERVICE_PATH/build/index.js"
12 | NUCLEI_PATH=$(which nuclei)
13 | COMMAND_NAME=$(basename "$SERVICE_PATH")
14 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
15 |
16 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
17 |
18 | jq --arg cmd "$COMMAND_NAME" \
19 | --arg node_path "$INDEX_PATH" \
20 | --arg bin_path "$NUCLEI_PATH" \
21 | '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
22 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/sqlmap-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | # Ensure sqlmap is installed and available in PATH
9 | SQLMAP_BIN=$(which sqlmap)
10 | [ -x "$SQLMAP_BIN" ] || exit 1
11 |
12 | SERVICE_PATH=$(pwd)
13 | INDEX_PATH="$SERVICE_PATH/build/index.js"
14 | COMMAND_NAME=$(basename "$SERVICE_PATH")
15 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
16 |
17 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
18 |
19 | jq --arg cmd "$COMMAND_NAME" \
20 | --arg index_path "$INDEX_PATH" \
21 | --arg bin_name "sqlmap" \
22 | '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
23 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/waybackurls-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | go install github.com/tomnomnom/waybackurls@latest
9 |
10 | WAYBACK_BIN=$(which waybackurls)
11 | [ -x "$WAYBACK_BIN" ] || exit 1
12 |
13 | SERVICE_PATH=$(pwd)
14 | INDEX_PATH="$SERVICE_PATH/build/index.js"
15 | COMMAND_NAME=$(basename "$SERVICE_PATH")
16 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
17 |
18 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
19 |
20 | jq --arg cmd "$COMMAND_NAME" \
21 | --arg index_path "$INDEX_PATH" \
22 | --arg bin_name "waybackurls" \
23 | '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
24 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/arjun-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null 2>&1
6 | npm run build >/dev/null 2>&1
7 |
8 | # Activate shared venv (defined in Dockerfile)
9 | source /opt/venv/bin/activate
10 |
11 | pip install arjun >/dev/null
12 |
13 | SERVICE_PATH=$(pwd)
14 | INDEX_PATH="$SERVICE_PATH/build/index.js"
15 | ARJUN_PATH=$(which arjun)
16 | COMMAND_NAME=$(basename "$SERVICE_PATH")
17 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
18 |
19 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
20 |
21 | jq --arg cmd "$COMMAND_NAME" \
22 | --arg node_path "$INDEX_PATH" \
23 | --arg arjun_path "$ARJUN_PATH" \
24 | '.[$cmd] = { "command": "node", "args": [$node_path, $arjun_path] }' \
25 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```
--------------------------------------------------------------------------------
/start.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | echo "[*] Starting all services..."
4 |
5 | # Loop through all directories in the current folder
6 | for dir in */ ; do
7 | # Remove trailing slash
8 | dir=${dir%/}
9 |
10 | # Skip if not a directory
11 | [ -d "$dir" ] || continue
12 |
13 | # Check if build.sh exists in the directory
14 | if [ -f "$dir/build.sh" ]; then
15 | echo "[+] Found build.sh in $dir, executing..."
16 | chmod +x "$dir/build.sh"
17 | (cd "$dir" && ./build.sh)
18 | else
19 | echo "[-] No build.sh found in $dir, skipping..."
20 | fi
21 | done
22 |
23 | jq '{mcpServers: with_entries(.value += {dockerContainer: ""})}' mcp-config.json > mcp-config.tmp && mv mcp-config.tmp mcp-config.json
24 |
25 | echo "[*] All build scripts executed. Container will now remain running."
26 |
27 | cat mcp-config.json
```
--------------------------------------------------------------------------------
/smuggler-mcp/build.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | npm install >/dev/null
6 | npm run build >/dev/null
7 |
8 | # Clone Smuggler if not already present
9 | [ -d "/opt/smuggler" ] || git clone https://github.com/defparam/smuggler /opt/smuggler
10 |
11 | PYTHON_PATH=$(which python3)
12 | SMUGGLER_PATH="/opt/smuggler/smuggler.py"
13 | SERVICE_PATH=$(pwd)
14 | INDEX_PATH="$SERVICE_PATH/build/index.js"
15 | COMMAND_NAME=$(basename "$SERVICE_PATH")
16 | CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
17 |
18 | [ -f "$SMUGGLER_PATH" ] || exit 1
19 | [ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"
20 |
21 | jq --arg cmd "$COMMAND_NAME" \
22 | --arg index_path "$INDEX_PATH" \
23 | --arg py_path "$PYTHON_PATH" \
24 | --arg smuggler_path "$SMUGGLER_PATH" \
25 | '.[$cmd] = { "command": "node", "args": [$index_path, $py_path, $smuggler_path] }' \
26 | "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```