This is page 1 of 2. Use http://codebase.md/cyproxio/mcp-for-security?format=md&lines=false&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:
--------------------------------------------------------------------------------

```
mcp-config.json
```

--------------------------------------------------------------------------------
/smuggler-mcp/.gitignore:
--------------------------------------------------------------------------------

```
node_modules/
build/
*.log 
```

--------------------------------------------------------------------------------
/ffuf-mcp/.gitignore:
--------------------------------------------------------------------------------

```
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/alterx-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/amass-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/arjun-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/assetfinder-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/cero/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/commix-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/crtsh-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/httpx-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/katana-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/masscan-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/mobsf-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/nmap-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/nuclei-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/scoutsuite-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/shuffledns-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/sqlmap-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/sslscan-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/waybackurls-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/wpscan-mcp/.gitignore:
--------------------------------------------------------------------------------

```
# Dependency directories
node_modules/
jspm_packages/
build/
```

--------------------------------------------------------------------------------
/gowitness-mcp/.gitignore:
--------------------------------------------------------------------------------

```
node_modules
screenshots
test-output
test-screenshots
test-runner.js
build/
```

--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------

```
# Git metadata
.git
.gitignore

**/node_modules

**/build

# Log dosyaları
*.log
npm-debug.log

tmp
*.tmp
.vscode
.idea

.env
.env.local
.env.*.local

Dockerfile
README.md
*.md
tests
```

--------------------------------------------------------------------------------
/commix-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown

```

--------------------------------------------------------------------------------
/smuggler-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Smuggler MCP

> Model Context Protocol (MCP) integration for Smuggler, a tool for detecting HTTP Request Smuggling / Desync vulnerabilities.

## Overview

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.

## Installation

### Prerequisites

- Node.js (v16+)
- Python 3.x
- Smuggler (smuggler.py) downloaded from [defparam/smuggler](https://github.com/defparam/smuggler)

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd smuggler-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```


## Usage

### Basic Configuration

To configure the Smuggler MCP server in your MCP client setup:

```json
{
  "smuggler": {
    "command": "node",
    "args": [
      "/path/to/smuggler-mcp/build/index.js",
      "/path/to/python"
      "/path/to/smuggler/smuggler.py"
    ]
  }
}
```

### Example Usage

```javascript
// Run HTTP Request Smuggling test
const result = await mcp.tools.invoke("do-smuggler", {
  url: "http://example.com" 
});

// Test with additional parameters
const result = await mcp.tools.invoke("do-smuggler", {
  url: "http://example.com",
  smuggler_args: ["-m", "GET", "--timeout", "10"]
});
```

### Supported Parameters

- `url`: URL to test (required)
- `smuggler_args`: Additional Smuggler parameters (optional)
  - `-m, --method`: HTTP method (GET, POST, etc.)
  - `-v, --vhost`: Virtual host
  - `-t, --timeout`: Timeout value
  - `-x`: Exit on first finding
  - `--verify`: Level of verification for findings

## Integration with AI Assistants
Smuggler MCP is designed to work with AI assistants that support the Model Context Protocol, enabling natural language interactions for vulnerability testing.

```
User: Can you test this internal site for HTTP request smuggling? http://internal.corp
AI: Running HTTP Request Smuggling tests on http://internal.corp using Smuggler...

[AI runs Smuggler MCP and returns the parsed results]

Smuggler found a potential CL.TE vulnerability using mutation XYZ...
```
## Security Considerations

- Use Smuggler only with explicit authorization
- Target only systems you own or have permission to test
- Avoid triggering backend systems unintentionally
- Use responsibly and ethically


## Troubleshooting

1. Verify Python and smuggler.py are accessible and working
2. Ensure the paths in your configuration are correct
3. Check output logs for Python errors
4. Use verbose logging for debugging


## Acknowledgements

- [Smuggler](https://github.com/defparam/smuggler)
- [Model Context Protocol](https://github.com/modelcontextprotocol) 
```

--------------------------------------------------------------------------------
/scoutsuite-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Scout Suite MCP

> Scout Suite MCP is a bridge that integrates Scout Suite, a multi-cloud security auditing tool, with the Model Context Protocol (MCP) ecosystem.


## Overview

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.


## Features

- Multi-cloud support (AWS, Azure, GCP)
- Service and region-based filtering
- Multiple authentication methods (profile or access keys)
- Summary or full report generation
- Custom IP range mapping support
- Seamless integration with AI assistants via MCP
- Clean JSON output for further automation or reporting

### Cloud Providers Supported

| Provider | Description |
|------|-------------|
|AWS|Audit AWS accounts using profile or access keys. Filter services and regions.
|Azure|(Coming soon) Audit Azure subscriptions with token-based authentication.
|GCP|(Coming soon) Audit GCP projects via service account JSON credentials.


## Installation

### Prerequisites

- Node.js (v16 or higher)
- Scout Suite installed on your system
- MCP SDK

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd Scout Suite-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```

## Usage

### Basic Configuration

Configure the Scout Suite MCP server in your MCP client configuration:

```json
{
  "Scout Suite": {
    "command": "node",
    "args": [
      "/path/to/Scout Suite-mcp/build/index.js",
      "/path/to/scoutsuite binary"
    ]
  }
}
```


## Examples

### Audit an AWS Account

```javascript
const result = await mcp.tools.invoke("do-Scout Suite-aws", {
  profile: "prod-account",
  services: ["ec2", "s3", "iam"],
  regions: "us-east-1,eu-central-1",
  full_report: false
});
```


## Integration with AI Assistants
Scout Suite MCP is designed for direct use by AI agents to perform cloud security assessments through natural language requests.

Example conversation with an AI assistant:

```
User: Audit our AWS environment for misconfigurations.
AI: Running Scout Suite on AWS using profile "prod-account"...
[Scout Suite MCP invoked and returns the results] ...
```

## Troubleshooting

If you encounter issues:

1.	Ensure scout suite is installed and accessible in your terminal (which scout).
2.	Make sure your MCP configuration path points to the correct build output.
3.	Verify that the target parameter is a valid domain.
4.	Check logs for detailed error messages.

## Acknowledgments

- Scout Suite by NCC Group: https://github.com/nccgroup/Scout Suite
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/cero/readme.md:
--------------------------------------------------------------------------------

```markdown
# CERO MCP

> Cero MCP is a bridge that connects Cero, a high-performance TLS certificate scanner, with the Model Context Protocol (MCP) ecosystem.


## Overview

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.

## Installation

### Prerequisites

- Node.js (v16+)
- MCP SDK
- Go 1.18+ (if building Cero from source)
- Cero binary available in system path or specified manually

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd cero-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm run build
   ```


## Usage

### Basic Configuration

To configure the Cero MCP server in your MCP client setup:

```json
{
  "cero": {
    "command": "node",
    "args": [
      "/path/to/cero-mcp/build/index.js",
      "/usr/local/bin/cero"
    ]
  }
}
```

### Example Usage

#### Basic TSL Scan
```javascript
const result = await mcp.tools.invoke("do-cero", {
  target: "example.com"
});
```

#### Concurrent Scan with Custom Ports and Timeout
```javascript
const result = await mcp.tools.invoke("do-cero", {
  target: "192.168.1.0/24",
  concurrency: 100,
  ports: ["443", "8443", "993"],
  timeOut: 6
});
```

### Supported Parameters

- `target` (required): The target hostname, IP address, or CIDR range to scan
- `concurrency`: Maximum number of concurrent TLS connections (default varies)
- `ports`: List of ports to probe for TLS certificates (e.g., ["443", "8443"])
- `timeOut`: Timeout for each TLS connection in seconds (default: 4)

## Integration with AI Assistants
Cero MCP integrates directly into AI assistants that support the Model Context Protocol. This allows natural language instructions to trigger deep certificate-based enumeration.

```
User: Find subdomains for *.example.com using TLS certificate data.
AI: Running Cero scan against example.com on ports 443 and 8443...

[Cero MCP runs and returns discovered domains]

Results: Found 6 domains via certificate SAN fields including mail.example.com and api.example.com.
```
## Security Considerations

- Only scan IP ranges and hosts you are authorized to assess
- Excessive concurrency can lead to rate-limiting or blacklisting
- Always validate certificate data manually before further use
- Timeout values may affect results in high-latency environments


## Troubleshooting

1. Ensure the Cero binary is installed and accessible from the command line
2. Confirm network access to the target IP or domain
3. Make sure the target is accessible and valid


## Acknowledgements

- [cero](https://github.com/glebarez/cero)
- [Model Context Protocol](https://github.com/modelcontextprotocol) 
```

--------------------------------------------------------------------------------
/ffuf-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# FFUF MCP

> FFUF MCP is a bridge that connects FFUF (Fuzz Faster U Fool), the high-speed web fuzzer, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full FFUF functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- FFUF installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd ffuf-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the FFUF MCP server in your MCP client configuration:

```json
{
  "ffuf": {
    "command": "node",
    "args": [
      "/path/to/ffuf-mcp/build/index.js",
      "ffuf"
    ]
  }
}
```

### Running FFUF Tests

Once configured, you can run FFUF tests through the MCP interface using the `do-ffuf` tool:

```javascript
// Example of calling FFUF through MCP
const result = await mcp.tools.invoke("do-ffuf", {
  url: "http://example.com/FUZZ",
  ffuf_args: ["-w", "/path/to/wordlist.txt"]
});
```

### Available Options

FFUF MCP supports all standard FFUF parameters.
See the [FFUF documentation](https://github.com/ffuf/ffuf) for a full list of available options.

## Examples

### Directory Fuzzing

```javascript
const result = await mcp.tools.invoke("do-ffuf", {
  url: "http://target-website.com/FUZZ",
  ffuf_args: [
    "-w", "/path/to/common-directories.txt",
    "-mc", "200,204,301,302,307,401,403"
  ]
});
```

## Integration with AI Assistants

FFUF MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.

Example conversation with an AI assistant:

```
User: Fuzz for hidden directories on http://example.com
AI: I'll help you fuzz for hidden directories using FFUF.

[AI uses FFUF MCP to run the test and returns the results]

FFUF has discovered the following directories:
- /admin (Status: 301)
- /api (Status: 200)
- /backup (Status: 403)
...
```

## Troubleshooting

If you encounter issues:

1. Verify FFUF is properly installed and accessible
2. Check the path to the FFUF executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages

## Acknowledgments

- FFUF Project: https://github.com/ffuf/ffuf
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/nmap-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Nmap MCP

> Nmap MCP is a bridge that connects Nmap, the industry-standard network scanner, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full Nmap functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Nmap installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
  git clone https://github.com/cyproxio/mcp-for-security
 cd nmap-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Nmap MCP server in your MCP client configuration:

```json
{
  "nmap": {
    "command": "node",
    "args": [
      "/path/to/nmap-mcp/build/index.js",
      "nmap"
    ]
  }
}
```

### Running Nmap Scans

Once configured, you can run Nmap scans through the MCP interface using the `do-nmap` tool:

```javascript
// Example of calling Nmap through MCP
const result = await mcp.tools.invoke("do-nmap", {
  target: "192.168.1.1",
  nmap_args: ["-sV", "-p", "1-1000"]
});
```

### Available Options

Nmap MCP supports all standard Nmap parameters through the `nmap_args` array.

## Examples

### Basic Port Scan

```javascript
const result = await mcp.tools.invoke("do-nmap", {
  target: "192.168.1.1",
  nmap_args: ["-p", "1-1000"]
});
```
## Integration with AI Assistants

Nmap MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.

Example conversation with an AI assistant:

```
User: Scan the host 192.168.1.1 for open web servers and SSH
AI: I'll help you scan that host using Nmap.

[AI uses Nmap MCP to run the scan and returns the results]

Nmap scan results for 192.168.1.1:
- Port 22/tcp: open (SSH)
- Port 80/tcp: open (HTTP)
- Port 443/tcp: open (HTTPS)
...
```

## Security Considerations

- Always obtain proper authorization before scanning networks
- Use responsibly and ethically
- Be aware that some Nmap scan types can be detected by security systems
- Consider using quieter scan options in sensitive environments

## Troubleshooting

If you encounter issues:

1. Verify Nmap is properly installed and accessible
2. Check the path to the Nmap executable in your configuration
3. Ensure proper permissions are set for execution (some Nmap scan types require root/administrator privileges)
4. Review server logs for detailed error messages

## Acknowledgments

- Nmap Project: https://nmap.org
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/assetfinder-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Assetfinder MCP

> Assetfinder MCP is a bridge that connects Assetfinder, a subdomain discovery tool by Tomnomnom, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.


## Features

- Integration with Assetfinder for passive subdomain discovery
- Fast and lightweight enumeration of subdomains
- Optional discovery of related root domains
- Seamless usage within AI assistants or automation pipelines
- Standardized input/output handling through MCP

## Installation

### Prerequisites

- Node.js (v16 or higher)
- assetfinder installed on your system
- MCP SDK

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd assetfinder-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```

## Usage

### Basic Configuration

Configure the Assetfinder MCP server in your MCP client configuration:

```json
{
  "assetfinder": {
    "command": "node",
    "args": [
      "/path/to/assetfinder-mcp/build/index.js",
      "assetfinder"
    ]
  }
}
```

### Parameters
Assetfinder MCP supports the following parameter:
* target:  The domain name to enumerate subdomains for (e.g., example.com).


## Examples

### Basic Subdomain Enumeration

```javascript
const result = await mcp.tools.invoke("assetfinder", {
  target: "example.com"
});
```

### Use in an Automated Workflow

```javascript
const domains = ["example.com", "testsite.org"];
for (const domain of domains) {
  const result = await mcp.tools.invoke("assetfinder", { target: domain });
  console.log(`${domain} → ${result.join(", ")}`);
}
```


## Integration with AI Assistants
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.

Example conversation with an AI assistant:

```
User: Find all subdomains of example.com.
AI: Running assetfinder for example.com...

[AI uses Assetfinder MCP and returns the results]

I found the following subdomains:
- www.example.com
- api.example.com
- mail.example.com
...
```

## Security Considerations

- Assetfinder performs passive enumeration and does not actively scan the target.
- Ensure you have proper authorization to query domains.
- Use responsibly and in accordance with legal and ethical guidelines.

## Troubleshooting

If you encounter issues:

1.	Ensure assetfinder is installed and accessible in your terminal (which assetfinder).
2.	Make sure your MCP configuration path points to the correct build output.
3.	Verify that the target parameter is a valid domain.
4.	Check logs for detailed error messages.

## Acknowledgments

- Assetfinder by Tomnomnom: https://github.com/tomnomnom/assetfinder
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/masscan-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Masscan MCP

> Masscan MCP is a bridge that connects Masscan, the ultra-fast port scanner, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full Masscan functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Masscan installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd masscan-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Masscan MCP server in your MCP client configuration:

```json
{
  "masscan": {
    "command": "node",
    "args": [
      "/path/to/masscan-mcp/build/index.js",
      "masscan"
    ]
  }
}
```

### Running Masscan

Once configured, you can run Masscan through the MCP interface using the `do-masscan` tool:

```javascript
// Example of calling Masscan through MCP
const result = await mcp.tools.invoke("do-masscan", {
  target: "192.168.1.0/24",
  port: "80,443,8080"
});
```

### Parameters

Masscan MCP currently supports two main parameters:

- `target`: IP address or range to scan (e.g., "192.168.1.1", "10.0.0.0/24")
- `port`: Port or port ranges to scan (e.g., "80", "22-25", "80,443,8080")

## Examples

### Scan a Single Host

```javascript
const result = await mcp.tools.invoke("do-masscan", {
  target: "192.168.1.1",
  port: "1-65535"
});
```

## Integration with AI Assistants

Masscan MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.

Example conversation with an AI assistant:

```
User: Scan my local network 192.168.1.0/24 for web servers
AI: I'll help you scan your network for web servers using Masscan.

[AI uses Masscan MCP to run the scan and returns the results]

Masscan has found the following open web ports:
- 192.168.1.5:80
- 192.168.1.10:443
- 192.168.1.15:8080
...
```

## Security Considerations

- Always obtain proper authorization before scanning networks
- Use responsibly and ethically
- Be aware that Masscan is designed for speed and may generate significant network traffic
- Consider using slower scan rates in production environments

## Troubleshooting

If you encounter issues:

1. Verify Masscan is properly installed and accessible
2. Check the path to the Masscan executable in your configuration
3. Ensure proper permissions are set for execution (Masscan typically requires root/administrator privileges)
4. Review server logs for detailed error messages

## Advanced Usage

While the current MCP implementation provides basic functionality, Masscan itself supports many advanced features. Future versions of this bridge may include additional parameters. 

## Acknowledgments

- Masscan Project: https://github.com/robertdavidgraham/masscan
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/wpscan-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# WPSCAN MCP

> WPScan MCP is a bridge that connects WPScan, a powerful WordPress vulnerability scanner, with the Model Context Protocol (MCP) ecosystem.


## Overview

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.

## Installation

### Prerequisites

- Node.js (v16+)
- MCP SDK
- WPScan installed and executable from the command line

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd wpscan-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```


## Usage

### Basic Configuration

To configure the Smuggler MCP server in your MCP client setup:

```json
{
  "wpscan": {
    "command": "node",
    "args": [
      "/path/to/wpscan-mcp/build/index.js",
      "/usr/bin/wpscan"
    ]
  }
}
```

### Example Usage

#### Basic Scan
```javascript
const result = await mcp.tools.invoke("do-wpscan", {
  url: "https://example.com",
  enumerate: ["vp", "vt", "tt", "cb", "dbe"]
});
```

#### Stealthier Scan with Proxy and Random Agent
```javascript
const result = await mcp.tools.invoke("do-wpscan", {
  url: "https://example.com",
  detection_mode: "passive",
  proxy: "http://127.0.0.1:8080",
  random_user_agent: true
});
```

### Supported Parameters

- `url` (required): The target WordPress site to scan
- `detection_mode`: "mixed" (default), "passive", or "aggressive"
- `random_user_agent`: Whether to rotate user agents to avoid detection
- `max_threads`: Number of threads to speed up scanning (default: 5)
- `disable_tls_checks`: Disable TLS certificate validation
- `proxy`: Proxy to route traffic through (e.g., http://127.0.0.1:8080)
- `cookies`: Cookie string to use (e.g., PHPSESSID=1234; logged_in=true)
- `force`: Force scanning even if WP is not detected
- `enumerate`: Array of enumeration types:
  - `vp`: Vulnerable plugins
  - `ap`: All plugins
  - `p`: Popular plugins
  - `vt`: Vulnerable themes
  - `at`: All themes
  - `t`: Popular themes
  - `tt`: Timthumb vulnerabilities
  -	`cb`: Configuration backups
  -	`dbe`: Database exports

## Integration with AI Assistants
WPScan MCP works seamlessly with AI assistants that support the Model Context Protocol. This allows natural language commands to trigger WPScan in real-time.

```
User: Scan https://example.com for WordPress vulnerabilities.
AI: Running WPScan against https://example.com using passive detection...

[WPScan MCP runs and returns findings]

Results: 3 vulnerable plugins found, 1 outdated theme, timthumb vulnerability detected.
```
## Security Considerations

- Only scan sites you own or have explicit permission to test
- Aggressive scanning can trigger security alerts on target websites
- Passive mode is recommended for stealthy enumeration
- Always review output manually before making security decisions


## Troubleshooting

1. Ensure WPScan is installed and executable from CLI
2. Validate proxy and TLS settings are correct
3. Make sure the URL is accessible and valid
4. Use verbose output or server logs for error tracking


## Acknowledgements

- [WPScan](https://github.com/wpscanteam/wpscan)
- [Model Context Protocol](https://github.com/modelcontextprotocol) 
```

--------------------------------------------------------------------------------
/sqlmap-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# SQLMap MCP

> SQLMap MCP is a bridge that connects SQLMap, the popular SQL injection detection and exploitation tool, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full SQLMap functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- SQLMap installed on your system
- MCP SDK

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd sqlmap-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```

## Usage

### Basic Configuration

Configure the SQLMap MCP server in your MCP client configuration:

```json
{
  "sqlmap": {
    "command": "node",
    "args": [
      "/path/to/sqlmap-mcp/build/index.js",
      "sqlmap"
    ]
  }
}
```

### Running SQLMap Tests

Once configured, you can run SQLMap tests through the MCP interface using the `do-sqlmap` tool:

```javascript
// Example of calling SQLMap through MCP
const result = await mcp.tools.invoke("do-sqlmap", {
  url: "http://example.com/vulnerable.php?id=1",
  sqlmap_args: ["--batch", "--dbs"]
});
```

### Available Options

SQLMap MCP supports all standard SQLMap parameters.
See the [SQLMap documentation](https://github.com/sqlmapproject/sqlmap/wiki/Usage) for a full list of available options.

## Examples

### Basic Database Enumeration

```javascript
const result = await mcp.tools.invoke("do-sqlmap", {
  url: "http://vulnerable-website.com/page.php?id=1",
  sqlmap_args: ["--batch", "--dbs"]
});
```

### Targeted Table Dump

```javascript
const result = await mcp.tools.invoke("do-sqlmap", {
  url: "http://vulnerable-website.com/page.php?id=1",
  sqlmap_args: [
    "--batch",
    "-D", "target_database",
    "-T", "users",
    "--dump"
  ]
});
```

## Integration with AI Assistants

SQLMap MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.

Example conversation with an AI assistant:

```
User: Test this website for SQL injection: http://testphp.vulnweb.com/artists.php?artist=1
AI: I'll help you test that website for SQL injection vulnerabilities using SQLMap.

[AI uses SQLMap MCP to run the test and returns the results]

SQLMap has detected a potential SQL injection vulnerability in the 'artist' parameter...
```

## Security Considerations

- Always obtain proper authorization before testing websites for vulnerabilities
- Use responsibly and ethically
- Consider using `--random-agent` and proxies for more discreet testing

## Troubleshooting

If you encounter issues:

1. Verify SQLMap is properly installed and accessible
2. Check the path to the SQLMap executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages

## Acknowledgments

- SQLMap Project: https://github.com/sqlmapproject/sqlmap
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/arjun-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Arjun MCP

> Arjun MCP is a bridge that connects Arjun, a powerful HTTP parameter discovery tool, with the Model Context Protocol (MCP) ecosystem.



## Overview

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.


## Features

- Integration with Arjun to discover hidden HTTP parameters
- Support for scanning single URLs or multiple URLs from a file
- Custom wordlist support for flexible scanning
- Ability to specify HTTP methods (GET, POST, JSON, HEADERS)
- Rate limiting and chunk size configuration
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Arjun installed on your system
- MCP SDK

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd arjun-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```

## Usage

### Basic Configuration

Configure the Arjun MCP server in your MCP client configuration:

```json
{
  "arjun": {
    "command": "node",
    "args": [
      "/path/to/arjun-mcp/build/index.js",
      "arjun"
    ]
  }
}
```

### Parameters
Arjun MCP supports the following parameters:
- url: Target URL to scan for hidden parameters (required if textFile not provided)
- textFile: Path to file containing multiple URLs (optional)
- wordlist: Path to custom wordlist file for scanning (optional)
- method: HTTP method to use for scanning (optional)
- rateLimit: Maximum requests per second (optional, default: 9999)
- chunkSize: The number of parameters to be sent at once (optional)

## Examples

### Scan a Single URL 

```javascript
const result = await mcp.tools.invoke("arjun", {
  url: "https://example.com"
});
```

### Scan Multiple URLs from a File

```javascript
const result = await mcp.tools.invoke("arjun", {
  textFile: "/path/to/urls.txt"
});
```


### Use a Custom Wordlist and Specific Method

```javascript
const result = await mcp.tools.invoke("arjun", {
  url: "https://example.com",
  wordlist: "/path/to/wordlist.txt",
  method: "POST"
});
```


## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Find hidden parameters on https://example.com
AI: I'll run a scan for hidden HTTP parameters on https://example.com using Arjun.

[AI uses Arjun MCP to perform the scan and returns the results]

I discovered the following hidden parameters:
- user_id
- session_token
- debug
- preview_mode
...

Would you like me to test these parameters for vulnerabilities?
```

## Security Considerations

- This tool is intended for legitimate security research and testing
- Always obtain proper authorization before scanning websites
- Scanning can generate noticeable traffic; adjust rate limits if necessary
- Use responsibly and ethically
- Respect target websites’ terms of service and applicable laws

## Troubleshooting

If you encounter issues:

1. Verify Arjun is properly installed and accessible in your PATH
2. Check the path to the Arjun executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages

## Acknowledgments

- Arjun Project: https://github.com/s0md3v/Arjun
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/sslscan-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# SSLScan MCP

> SSLScan MCP is a bridge that connects SSLScan, the comprehensive SSL/TLS security testing tool, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full SSLScan functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling
- Support for all SSLScan options and configurations

## Installation

### Prerequisites

- Node.js (v16 or higher)
- SSLScan installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd sslscan-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the SSLScan MCP server in your MCP client configuration:

```json
{
  "sslscan": {
    "command": "node",
    "args": [
      "/path/to/sslscan-mcp/build/index.js",
      "sslscan"
    ]
  }
}
```

### Running SSLScan Tests

Once configured, you can run SSLScan tests through the MCP interface using the `do-sslscan` tool:

```javascript
// Example of calling SSLScan through MCP
const result = await mcp.tools.invoke("do-sslscan", {
  target: "https://example.com",
  sslscan_args: ["--no-fallback", "--no-heartbleed"]
});
```

### Available Options

SSLScan MCP supports all standard SSLScan parameters through the `sslscan_args` array. 

## Examples

### Basic SSL/TLS Assessment

```javascript
const result = await mcp.tools.invoke("do-sslscan", {
  target: "https://example.com",
  sslscan_args: []
});
```

### Check for Legacy Protocol Support

```javascript
const result = await mcp.tools.invoke("do-sslscan", {
  target: "https://example.com",
  sslscan_args: ["--ssl3", "--tls10"]
});
```

### Comprehensive SSL/TLS Audit

```javascript
const result = await mcp.tools.invoke("do-sslscan", {
  target: "https://example.com",
  sslscan_args: [
    "--show-certificate",
    "--show-ciphers",
    "--no-fallback",
    "--no-heartbleed"
  ]
});
```

### STARTTLS for Email Servers

```javascript
const result = await mcp.tools.invoke("do-sslscan", {
  target: "mail.example.com",
  sslscan_args: ["--starttls-smtp"]
});
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Check the SSL/TLS configuration of example.com
AI: I'll help you analyze the SSL/TLS configuration of example.com using SSLScan.

[AI uses SSLScan MCP to run the assessment and returns the results]

SSLScan results for example.com:
- TLSv1.0 is disabled
- TLSv1.3 is supported
- Weak ciphers are not supported
- Certificate is valid and trusted
- No Heartbleed vulnerability detected
...
```

## Security Considerations

- Always obtain proper authorization before testing websites
- Use responsibly and ethically
- Some tests may be logged by the target server's security monitoring systems

## Troubleshooting

If you encounter issues:

1. Verify SSLScan is properly installed and accessible
2. Check the path to the SSLScan executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages
5. Confirm that the target URL begins with `https://` for proper SSL/TLS scanning

## Acknowledgments

- SSLScan Project: https://github.com/rbsec/sslscan
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/nuclei-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Nuclei MCP

> Nuclei MCP is a bridge that connects Nuclei, the powerful vulnerability scanner, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling
- Access to Nuclei's extensive template library

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Nuclei installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd nuclei-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Nuclei MCP server in your MCP client configuration:

```json
{
  "nuclei": {
    "command": "node",
    "args": [
      "/path/to/nuclei-mcp/build/index.js",
      "nuclei"
    ]
  }
}
```

### Running Nuclei Scans

Once configured, you can run Nuclei scans through the MCP interface using the `do-nuclei` tool:

```javascript
// Example of calling Nuclei through MCP
const result = await mcp.tools.invoke("do-nuclei", {
  url: "https://example.com",
  tags: "cve,rce,tech"
});
```

### Getting Available Tags

You can retrieve all available Nuclei template tags using the `get-nuclei-tags` tool:

```javascript
// Get all available Nuclei tags
const tagsResult = await mcp.tools.invoke("get-nuclei-tags", {});
const tags = JSON.parse(tagsResult.content[0].text);
```

## Parameters

Nuclei MCP currently supports the following parameters:

- `url`: The target URL to scan (required)
- `tags`: Comma-separated list of template tags to filter which checks to run (optional)

## Examples

### Basic Vulnerability Scan

```javascript
const result = await mcp.tools.invoke("do-nuclei", {
  url: "https://target-website.com"
});
```

### Targeted Scan with Specific Tags

```javascript
const result = await mcp.tools.invoke("do-nuclei", {
  url: "https://target-website.com",
  tags: "cve,oast,ssrf"
});
```

## Integration with AI Assistants

Nuclei MCP is designed to work seamlessly with AI assistants that support the Model Context Protocol, enabling natural language interactions for security testing tasks.

Example conversation with an AI assistant:

```
User: Check example.com for common security vulnerabilities
AI: I'll help you scan example.com for security vulnerabilities using Nuclei.

[AI uses Nuclei MCP to run the scan and returns the results]

Nuclei scan results for example.com:
- Found CVE-2021-XXXX in the login page
- Detected an open redirect vulnerability
- Identified outdated WordPress version
...
```

## Security Considerations

- Always obtain proper authorization before scanning websites for vulnerabilities
- Use responsibly and ethically
- Consider the potential impact of active scanning on production systems
- Some templates may generate significant traffic or potentially disruptive tests

## Troubleshooting

If you encounter issues:

1. Verify Nuclei is properly installed and accessible
2. Check the path to the Nuclei executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages

## Future Enhancements

Future versions of this bridge may include additional parameters such as:

- Support for more Nuclei options (rate-limiting, concurrency, etc.)
- Template management and customization
- Scan reporting in various formats

## Acknowledgments

- Nuclei Project: https://github.com/projectdiscovery/nuclei
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/alterx-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Alterx MCP

> Alterx MCP is a bridge that connects Alterx, a powerful subdomain permutation tool, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Pattern-based wordlist generation for subdomain discovery
- Support for multiple permutation patterns and strategies
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Alterx installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd alterx-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Alterx MCP server in your MCP client configuration:

```json
{
  "alterx": {
    "command": "node",
    "args": [
      "/path/to/alterx-mcp/build/index.js",
      "alterx"
    ]
  }
}
```

### Running Alterx

Once configured, you can run Alterx through the MCP interface using the `do-alterx` tool:

```javascript
// Example of calling Alterx through MCP
const result = await mcp.tools.invoke("do-alterx", {
  domain: "api.example.com",
  pattern: "{{word}}-{{sub}}.{{suffix}}",
  outputFilePath: "wordlist.txt"
});
```

## Parameters

Alterx MCP supports the following parameters:

- `domain`: The target domain or subdomains to use as a base for creating permutations (required)
- `pattern`: The pattern template to use for generating wordlist variations (required)
- `outputFilePath`: Path where the generated wordlist should be saved (optional)

## Examples

### Basic Permutation

```javascript
const result = await mcp.tools.invoke("do-alterx", {
  domain: "api.example.com",
  pattern: "{{sub}}-{{word}}.{{suffix}}"
});
```

### Multiple Patterns

```javascript
const result = await mcp.tools.invoke("do-alterx", {
  domain: "api.example.com",
  pattern: "{{sub}}-{{word}}.{{suffix}},{{word}}.{{sub}}.{{suffix}}",
  outputFilePath: "combined_wordlist.txt"
});
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Generate subdomain permutations for api.example.com
AI: I'll help you generate subdomain permutations using Alterx.

[AI uses Alterx MCP to run the permutation and returns the results]

I've generated the following subdomain permutations:
- dev-api.example.com
- stage-api.example.com
- test-api.example.com
- api-dev.example.com
- api-stage.example.com
...
```

## Security Considerations

- Always obtain proper authorization before scanning domains for subdomains
- Use responsibly and ethically
- This tool is intended for legitimate security research and testing

## Troubleshooting

If you encounter issues:

1. Verify Alterx is properly installed and accessible
2. Check the path to the Alterx executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages

## Advanced Usage

In more complex scenarios, you can:

1. Chain Alterx with other subdomain discovery tools in your MCP environment
2. Create custom wordlists for different patterns and reuse them across scans
3. Build automated workflows that generate permutations and then validate discovered subdomains

## Acknowledgments

- Alterx Project: https://github.com/projectdiscovery/alterx
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/katana-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Katana MCP

> Katana MCP is a bridge that connects Katana, a fast and customizable web crawler, with the Model Context Protocol (MCP) ecosystem.


## Overview

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.


## Features

- Integration with Katana for high-performance web crawling
- JavaScript endpoint parsing and JSluice support
- Configurable crawling strategies (depth-first or breadth-first)
- Headless browser-based crawling (experimental)
- Local Chrome integration support
- Custom header and cookie injection
- Easy integration with AI assistants or automated testing tools
- Standardized input/output handling through MCP

## Installation

### Prerequisites

- Node.js (v16 or higher)
- katana installed on your system
- MCP SDK

### Setup

1. Clone this repository:
   ```
   git clone https://github.com/cyproxio/mcp-for-security
   cd katana-mcp
   ```

2. Install dependencies:
   ```
   npm install
   ```

3. Build the project:
   ```
   npm install && npm run build
   ```

## Usage

### Basic Configuration

Configure the Katana MCP server in your MCP client configuration:

```json
{
  "katana": {
    "command": "node",
    "args": [
      "/path/to/katana-mcp/build/index.js",
      "katana"
    ]
  }
}
```

### Parameters
Katana MCP supports the following parameters:
- target (required): List of target URLs (e.g., https://example.com) to scan.
- exclude: URLs or patterns to exclude from crawling.
- depth: Maximum crawl depth.
- js_crawl: Enable endpoint parsing from JavaScript files.
- jsluice: Enable memory-intensive JSluice parsing.
- headers: List of custom headers/cookies in Header:Value format.
- strategy: Crawling strategy (depth-first or breadth-first). Default: depth-first.
- headless: Enable headless hybrid crawling using a browser (experimental).
- system_chrome: Use system-installed Chrome instead of bundled version.
- show_brwoser: Show the browser window even when headless mode is active.

## Examples

### Basic Crawl on a Single Target

```javascript
const result = await mcp.tools.invoke("katana", {
  target: ["https://example.com"]
});
```

### Crawl with JavaScript Parsing and Depth

```javascript
const result = await mcp.tools.invoke("katana", {
  target: ["https://example.com"],
  depth: 3,
  js_crawl: true
});
```


### Headless Browser Crawling with Custom Headers

```javascript
const result = await mcp.tools.invoke("katana", {
  target: ["https://example.com"],
  headless: true,
  headers: ["Authorization: Bearer TOKEN", "Cookie: session=abcd1234"]
});
```


## Integration with AI Assistants
Katana MCP is optimized for use with AI assistants that support the Model Context Protocol. This enables natural language-driven reconnaissance and crawling tasks.

Example conversation with an AI assistant:

```
User: Crawl https://example.com and extract all endpoints.
AI: Starting a deep crawl on https://example.com using Katana...

[AI uses Katana MCP and returns the results]

I found the following endpoints:
- /api/user
- /assets/js/app.js
- /admin/dashboard
...

Would you like to analyze the JavaScript files for hidden endpoints?
```

## Security Considerations

- Use only on systems you are authorized to scan.
- Crawling can be intensive and may be flagged as suspicious — adjust rate, depth, and headers appropriately.
- Use responsibly and in compliance with legal and ethical standards.

## Troubleshooting

If you encounter issues:

1.	Ensure Katana is installed and accessible from your terminal.
2.	Check that the command path in your MCP config points to the correct build file.
3.	Validate all required parameters are passed.
4.	Review logs for execution errors.

## Acknowledgments

- Katana Project: https://github.com/projectdiscovery/katana
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/crtsh-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# CRTSH MCP

> 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.

## Overview

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.

## Features

- Integration with Certificate Search (crt.sh) to fetch subdomains from SSL certificate logs
- Comprehensive subdomain discovery without active scanning
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd crtsh-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Certificate Search MCP server in your MCP client configuration:

```json
{
  "crtsh": {
    "command": "node",
    "args": [
      "/path/to/crtsh-mcp/build/index.js",
    ]
  }
}
```

### Running crt.sh

Once configured, you can run Certificate Search through the MCP interface using the `crtsh tool:

```javascript
// Example of calling Certificate Search through MCP for a domain
const result = await mcp.tools.invoke("crtsh", {
  target: "example.com"
});
```

## Parameters

Certificate Search MCP supports the following parameters:

- `target`: The domain to retrieve subdomains for (required)

## Examples

### Gather All Historical URLs

```javascript
const result = await mcp.tools.invoke("crtsh", {
  target: "example.com"
});
```

### Process Results for Further Analysis

```javascript
const result = await mcp.tools.invoke("crtsh", {
  target: "example.com"
});

// Parse the JSON results
const domains = JSON.parse(result.content[0].text);

// Filter for specific patterns or categories
const devDomains = domains.filter(domain => domain.includes('dev'));
const apiDomains = domains.filter(domain => domain.includes('api'));
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Find subdomains for example.com
AI: I'll discover subdomains for example.com using SSL certificate logs.

[AI uses Certificate Search MCP to fetch the subdomains and returns the results]

I found the following subdomains for example.com:
- api.example.com
- dev.example.com
- staging.example.com
- mail.example.com
- intranet.example.com
...
```

## Security Considerations

- This tool is intended for legitimate security research and testing
- Always obtain proper authorization before scanning websites
- Use responsibly and ethically
- The tool only retrieves information already publicly available in certificate transparency logs

## Troubleshooting

If you encounter issues:

1. Verify network connectivity to certificate transparency logs
2. Check that the domain has SSL certificates registered
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages
5. Some domains may have limited or no certificates in transparency logs

## Usage Tips

- Combine Certificate Search results with other reconnaissance tools for more comprehensive target information
- Look for interesting or unusual subdomains that might indicate sensitive services
- Use the discovered subdomains as input for further security testing
- Regularly monitor changes in subdomain structure to identify new attack surfaces

## Acknowledgments

- Certificate Search Project: https://crt.sh/
- Certificate Transparency: https://certificate.transparency.dev/
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/mobsf-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# MobSF MCP

> 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.

## Overview

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.

## Features

- MobSF functionality exposed through MCP
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling
- Support for Android (APK), iOS (IPA), and Windows (APPX) mobile applications

## Installation

### Prerequisites

- Node.js (v16 or higher)
- MobSF server installed and running
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd mobsf-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the MobSF MCP server in your MCP client configuration:

```json
{
  "mobsf": {
    "command": "node",
    "args": [
      "/path/to/mobsf-mcp/build/index.js",
      "http://localhost:8000",
      "your_mobsf_api_key"
    ]
  }
}
```

The configuration requires two parameters:
- The MobSF server URL (e.g., `http://localhost:8000`)
- Your MobSF API key

### Available Tools

MobSF MCP provides several tools for interacting with the MobSF server:

#### uploadFile

Upload a mobile application for analysis.

```javascript
const result = await mcp.tools.invoke("uploadFile", {
  file: "/path/to/application.apk"
});
```

#### scanFile

Scan a previously uploaded mobile application.

```javascript
const result = await mcp.tools.invoke("scanFile", {
  hash: "file_hash_from_upload",
  reScan: false // Optional, set to true to force a rescan
});
```

#### getScanLogs

Retrieve detailed scan logs for a previously analyzed application.

```javascript
const result = await mcp.tools.invoke("getScanLogs", {
  hash: "file_hash"
});
```

#### getJsonReport

Generate and retrieve a comprehensive security analysis report in JSON format.

```javascript
const result = await mcp.tools.invoke("getJsonReport", {
  hash: "file_hash"
});
```

#### getRecentScans

Retrieve a list of recently performed security scans.

```javascript
const result = await mcp.tools.invoke("getRecentScans", {
  page: 1,
  pageSize: 10
});
```

## Examples

### Complete Analysis Workflow

```javascript
// Step 1: Upload the mobile application
const uploadResult = await mcp.tools.invoke("uploadFile", {
  file: "/path/to/application.apk"
});

const fileHash = uploadResult.hash;

// Step 2: Scan the uploaded application
const scanResult = await mcp.tools.invoke("scanFile", {
  hash: fileHash
});

// Step 3: Generate a security report
const reportResult = await mcp.tools.invoke("getJsonReport", {
  hash: fileHash
});

// Process the report data as needed
```

### Viewing Recent Scans

```javascript
const recentScans = await mcp.tools.invoke("getRecentScans", {
  page: 1,
  pageSize: 20
});

// Process the list of recent scans
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Analyze this Android app for security vulnerabilities: /Downloads/my_app.apk
AI: I'll help you analyze this Android application using MobSF.

[AI uses MobSF MCP to upload and scan the app, then presents the results]

Security Analysis Summary for my_app.apk:
- 3 Critical vulnerabilities detected
- 7 High-risk issues identified
- Insecure data storage practices found
- Excessive permissions requested
...
```

## Security Considerations

- Always analyze applications you have permission to test
- Keep your MobSF server and API keys secure
- Consider the privacy implications of uploading sensitive applications
- Use isolated environments for testing potentially malicious applications

## Troubleshooting

If you encounter issues:

1. Verify the MobSF server is running and accessible
2. Check that your API key is correct and has not expired
3. Ensure file paths are correct and the files are accessible
4. Review server logs for detailed error messages



## Acknowledgments

- MobSF Project: https://github.com/MobSF/Mobile-Security-Framework-MobSF
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# HTTP Headers Security MCP

> HTTP Headers Security MCP is a bridge that connects HTTP header security analysis capabilities with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Analysis of HTTP response headers against OWASP security standards
- Identification of security headers that should be removed
- Recommendations for missing security headers that should be added
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- MCP SDK
- Axios for HTTP requests

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security

 cd http-headers-security-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the HTTP Headers Security MCP server in your MCP client configuration:

```json
{
  "http-headers-security": {
    "command": "node",
    "args": [
      "/path/to/http-headers-security-mcp/build/index.js"
    ]
  }
}
```

### Analyzing HTTP Headers

Once configured, you can analyze HTTP headers through the MCP interface using the `analyze-http-header` tool:

```javascript
// Example of analyzing HTTP headers through MCP
const result = await mcp.tools.invoke("analyze-http-header", {
  target: "https://example.com"
});

// Parse the JSON result
const headerAnalysis = JSON.parse(result.content[0].text);

// Access the results
const headersToRemove = headerAnalysis.removeHeaders;
const headersToAdd = headerAnalysis.addedHeaders;
```

## How It Works

The HTTP Headers Security MCP works by:

1. Making an HTTP request to the target URL
2. Collecting all HTTP response headers
3. Comparing the headers against two OWASP-based reference lists:
   - Headers that should be removed for security reasons (from `owasp_headers_remove.json`)
   - Headers that should be added for enhanced security (from `owasp_headers_add.json`)
4. Returning a comprehensive analysis with specific recommendations

## Example Response

```json
{
  "removeHeaders": [
    "Server: Apache/2.4.41",
    "X-Powered-By: PHP/7.4.3"
  ],
  "addedHeaders": [
    "Content-Security-Policy: default-src 'self'",
    "X-Frame-Options: DENY",
    "X-Content-Type-Options: nosniff",
    "Strict-Transport-Security: max-age=31536000; includeSubDomains"
  ]
}
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Check the security headers of example.com
AI: I'll analyze the HTTP security headers for example.com.

[AI uses HTTP Headers Security MCP to run the analysis and returns the results]

Here's my security header analysis for example.com:

Headers that should be removed:
- Server: Apache/2.4.41 (reveals server software information)
- X-Powered-By: PHP/7.4.3 (reveals technology stack)

Missing security headers that should be added:
- Content-Security-Policy: to prevent XSS attacks
- X-Frame-Options: to prevent clickjacking
- X-Content-Type-Options: to prevent MIME-type sniffing
- Strict-Transport-Security: to enforce HTTPS

These changes would significantly improve the security posture of the website.
```

## Security Considerations

- Always obtain proper authorization before scanning websites
- Use responsibly and ethically
- This tool only analyzes HTTP headers and does not perform invasive testing

## Troubleshooting

If you encounter issues:

1. Verify the target URL is accessible
2. Check for any network restrictions or firewalls
3. Ensure the reference JSON files are correctly formatted and loaded
4. Review server logs for detailed error messages

## Advanced Usage

You can enhance this tool by:

1. Adding custom header security rules
2. Integrating with other security testing frameworks
3. Implementing severity ratings for findings
4. Creating detailed reports with remediation guidance

## Acknowledgments

- OWASP Secure Headers Project: https://owasp.org/www-project-secure-headers/
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/shuffledns-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# shuffledns MCP

> shuffledns MCP is a bridge that connects shuffledns, a fast and powerful DNS enumeration tool, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Integration with shuffledns for fast DNS brute force and resolution
- Support for different operational modes: bruteforce, resolve, and filter
- Ability to use custom resolvers and wordlists
- Optional rate limiting for fine-tuned performance
- Simple configuration and setup
- Standardized input/output handling compatible with other MCP tools

## Installation

### Prerequisites

- Node.js (v16 or higher)
- shuffledns and massdns installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd shuffledns-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the shuffledns MCP server in your MCP client configuration:

```json
{
  "shuffledns": {
    "command": "node",
    "args": [
      "/path/to/shuffledns-mcp/build/index.js",
      "shuffledns",
      "massdns"
    ]
  }
}
```

### Running shuffledns

Once configured, you can run shuffledns through the MCP interface using the shuffledns tool:

```javascript
// Example of calling shuffledns through MCP
const result = await mcp.tools.invoke("shuffledns", {
  target: "example.com",
  resolver: "/path/to/resolvers.txt",
  mode: "bruteforce",
  wordlist: "/path/to/wordlist.txt",
  rateLimit: 1000 // optional
});

```

## Parameters

shuffledns MCP supports the following parameters:
- target: Domain name to scan (e.g., example.com) (required)
- resolver: Path to the resolver file containing DNS resolvers (required)
- mode: The operation mode to use:
  - bruteforce: Perform a DNS brute force attack using a wordlist
  - resolve: Resolve a list of domain names
  - filter: Filter a list of subdomains to find active hosts
  - wordlist: Path to the wordlist for subdomain enumeration (required)
- rateLimit: Number of DNS requests per second (optional)

## Examples

### Basic DNS Brute Forcing

```javascript
const result = await mcp.tools.invoke("shuffledns", {
  target: "example.com",
  resolver: "/path/to/resolvers.txt",
  mode: "bruteforce",
  wordlist: "/path/to/wordlist.txt"
});
```

### DNS Resolution of Existing Subdomains

```javascript
const result = await mcp.tools.invoke("shuffledns", {
  target: "example.com",
  resolver: "/path/to/resolvers.txt",
  mode: "resolve",
  wordlist: "/path/to/existing-subdomains.txt"
});
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Find subdomains for example.com
AI: I'll perform a DNS brute force on example.com to discover subdomains.

[AI uses shuffledns MCP to scan the domain and returns the results]

I found the following subdomains:
- api.example.com
- mail.example.com
- dev.example.com

Would you like me to check if they are active?
```

## Security Considerations

- This tool is intended for authorized security testing and research purposes only.
- Always obtain proper authorization before performing scans on external systems.
- Be mindful of DNS resolver usage policies and avoid abuse.
- Use responsible scanning practices and respect target systems.


## Troubleshooting

If you encounter issues:

1.	Ensure shuffledns is properly installed and accessible in the system PATH.
2.  Ensure massdns is properly installed and accessible in the system PATH.
3.	Check if the resolver file and wordlist paths are correct.
4.	Review server logs for detailed error messages.
5.	Adjust rate limits if DNS errors or throttling occur.


## Usage Tips

- Use high-quality resolvers for faster and more reliable results.
- Combine shuffledns output with HTTP probes (e.g., httpx) for comprehensive asset discovery.
- Use filtering mode after brute forcing to identify only live subdomains.
- Adjust rate limits based on your system and resolver capabilities to avoid packet loss.

## Acknowledgments

- shuffledns Project: https://github.com/projectdiscovery/shuffledns
- massdns Project: https://github.com/blechschmidt/massdns
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/waybackurls-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Waybackurls MCP

> 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.

## Overview

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.

## Features

- Integration with Waybackurls to fetch historical URLs from the Wayback Machine
- Option to include or exclude subdomains in the search
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Waybackurls installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd waybackurls-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Waybackurls MCP server in your MCP client configuration:

```json
{
  "waybackurls": {
    "command": "node",
    "args": [
      "/path/to/waybackurls-mcp/build/index.js",
      "waybackurls"
    ]
  }
}
```

### Running Waybackurls

Once configured, you can run Waybackurls through the MCP interface using the `do-waybackurls` tool:

```javascript
// Example of calling Waybackurls through MCP for a domain including subdomains
const result = await mcp.tools.invoke("do-waybackurls", {
  target: "example.com",
  noSub: false
});

// Example of calling Waybackurls through MCP for a domain excluding subdomains
const resultNoSubs = await mcp.tools.invoke("do-waybackurls", {
  target: "example.com",
  noSub: true
});
```

## Parameters

Waybackurls MCP supports the following parameters:

- `target`: The domain to retrieve historical URLs for (required)
- `noSub`: Boolean flag to control whether subdomains should be included (default: false)

## Examples

### Gather All Historical URLs

```javascript
const result = await mcp.tools.invoke("do-waybackurls", {
  target: "example.com",
  noSub: false
});
```

### Gather Historical URLs for Main Domain Only

```javascript
const result = await mcp.tools.invoke("do-waybackurls", {
  target: "example.com",
  noSub: true
});
```

### Process Results for Further Analysis

```javascript
const result = await mcp.tools.invoke("do-waybackurls", {
  target: "example.com"
});

// Split the results into individual URLs
const urls = result.content[0].text.trim().split('\n');

// Filter for specific file types or patterns
const jsFiles = urls.filter(url => url.endsWith('.js'));
const apiEndpoints = urls.filter(url => url.includes('/api/'));
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Find historical URLs for example.com
AI: I'll retrieve historical URLs for example.com using the Wayback Machine.

[AI uses Waybackurls MCP to fetch the URLs and returns the results]

I found the following interesting historical endpoints for example.com:
- Several old API endpoints: /api/v1/users, /api/v2/products
- Previously accessible admin pages: /admin/dashboard, /admin/users
- Backup files: /backup/db.sql, /backup/config.old
...
```

## Security Considerations

- This tool is intended for legitimate security research and testing
- Always obtain proper authorization before scanning websites
- Use responsibly and ethically
- The tool only retrieves information already publicly archived by the Internet Archive

## Troubleshooting

If you encounter issues:

1. Verify Waybackurls is properly installed and accessible
2. Check the path to the Waybackurls executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages
5. Some domains may have limited or no history in the Wayback Machine

## Usage Tips

- Combine Waybackurls results with other reconnaissance tools for more comprehensive target information
- Filter results to focus on specific file types or directories of interest
- Look for patterns in historical URLs that might indicate abandoned features or testing endpoints
- Use the results to inform your security testing or bug bounty hunting

## Acknowledgments

- Waybackurls Project: https://github.com/tomnomnom/waybackurls
- Internet Archive Wayback Machine: https://archive.org/web/
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/amass-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Amass MCP

> 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.

## Overview

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.

## Features

- Integration with Amass to perform advanced subdomain enumeration and reconnaissance
- Support for both passive and active enumeration modes
- Intelligence gathering capabilities with organization and WHOIS lookups
- Brute force subdomain discovery with custom wordlist support
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Amass installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd amass-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the Amass MCP server in your MCP client configuration:

```json
{
  "amass": {
    "command": "node",
    "args": [
      "/path/to/amass-mcp/build/index.js",
      "amass"
    ]
  }
}
```

### Running Amass

Once configured, you can run Amass through the MCP interface using the `amass` tool with various subcommands:

```javascript
// Example of calling Amass enum through MCP for passive reconnaissance
const result = await mcp.tools.invoke("amass", {
  subcommand: "enum",
  domain: "example.com",
  enum_type: "passive"
});

// Example of calling Amass intel with organization search
const intelResult = await mcp.tools.invoke("amass", {
  subcommand: "intel",
  intel_organization: "Example Corp",
  intel_whois: true
});
```

## Parameters

Amass MCP supports the following parameters:

- `subcommand`: The Amass operation mode to use (required)
  - `enum`: Perform subdomain enumeration and network mapping
  - `intel`: Gather intelligence about target domains from various sources

- For `enum` subcommand:
  - `domain`: Target domain to perform reconnaissance against (required)
  - `enum_type`: Enumeration approach type (optional)
    - `active`: Includes DNS resolution and potential network interactions with target
    - `passive`: Only uses information from third-party sources without direct target interaction
  - `enum_brute`: Whether to perform brute force subdomain discovery (optional)
  - `enum_brute_wordlist`: Path to custom wordlist file for brute force operations (optional)

- For `intel` subcommand:
  - `domain`: Target domain to gather intelligence on (optional if organization is provided)
  - `intel_organization`: Organization name to search for (optional if domain is provided)
  - `intel_whois`: Whether to include WHOIS data in intelligence gathering (optional)

## Examples

### Passive Subdomain Enumeration

```javascript
const result = await mcp.tools.invoke("amass", {
  subcommand: "enum",
  domain: "example.com",
  enum_type: "passive"
});
```

### Active Subdomain Enumeration with Brute Force

```javascript
const result = await mcp.tools.invoke("amass", {
  subcommand: "enum",
  domain: "example.com",
  enum_type: "active",
  enum_brute: true,
  enum_brute_wordlist: "/path/to/subdomains.txt"
});
```

### Intelligence Gathering for an Organization

```javascript
const result = await mcp.tools.invoke("amass", {
  subcommand: "intel",
  intel_organization: "Example Corp",
  intel_whois: true
});
```

### Domain Intelligence with WHOIS

```javascript
const result = await mcp.tools.invoke("amass", {
  subcommand: "intel",
  domain: "example.com",
  intel_whois: true
});
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Perform reconnaissance on example.com
AI: I'll run a passive subdomain enumeration for example.com using Amass.

[AI uses Amass MCP to perform the enumeration and returns the results]

I found the following subdomains for example.com:
- api.example.com
- mail.example.com
- dev.example.com
- admin.example.com
- staging.example.com
...

Would you like me to gather intelligence about the organization as well?
```

## Security Considerations

- This tool is intended for legitimate security research and testing
- Always obtain proper authorization before scanning websites
- Active enumeration may generate significant traffic to the target
- Use responsibly and ethically
- Consider using passive mode for initial reconnaissance to minimize detection

## Troubleshooting

If you encounter issues:

1. Verify Amass is properly installed and accessible in your PATH
2. Check the path to the Amass executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages
5. For large domains, consider increasing timeouts or memory limits

## Usage Tips

- Combine Amass results with other reconnaissance tools for more comprehensive target information
- Start with passive enumeration before using active techniques
- Use custom wordlists tailored to the target's industry or technology stack
- Filter results to focus on interesting subdomains that might indicate sensitive services
- Use the intel subcommand to discover related domains and organizations

## Acknowledgments

- Amass Project: https://github.com/OWASP/Amass
- OWASP Foundation
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/gowitness-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# Gowitness MCP

> Gowitness MCP is a bridge that connects gowitness, the powerful web screenshot and reconnaissance tool, with the Model Context Protocol (MCP) ecosystem.

## Overview

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.

## Features

- Full gowitness functionality exposed through MCP
- Flexible storage options: save to disk or return binary data
- Batch screenshot processing for multiple URLs
- Support for both JPEG and PNG formats
- Advanced Chrome browser configuration options
- Database and JSON export capabilities
- File management and binary data access tools
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- Go (for installing gowitness)
- gowitness installed on your system
- MCP SDK

### Setup

1. Clone this repository:
    
    ```bash
    git clone https://github.com/cyproxio/mcp-for-security
    cd gowitness-mcp
    ```
    
2. Install gowitness:
    
    ```bash
    go install github.com/sensepost/gowitness@latest
    ```
    
3. Install dependencies and build:
    
    ```bash
    npm install && npm run build
    ```
    
4. Configure for Claude (automated):
    
    ```bash
    # Windows PowerShell
    .\setup-mcp.ps1
    
    # Unix/Linux/macOS
    ./build.sh
    ```
    

## Usage

### Basic Configuration

Configure the Gowitness MCP server in your MCP client configuration:

```json
{
  "mcpServers": {
    "gowitness": {
      "command": "node",
      "args": [
        "/path/to/gowitness-mcp/build/index.js",
        "gowitness"
      ],
      "env": {
        "PATH": "${PATH}"
      }
    }
  }
}
```

### Taking Screenshots

Once configured, you can capture web screenshots through the MCP interface using the available tools:

#### Single Screenshot (Binary Return)

```javascript
// Screenshot without saving to disk - returns binary data
const result = await mcp.tools.invoke("gowitness-screenshot", {
  url: "https://example.com"
});
```

#### Single Screenshot (Save to Directory)

```javascript
// Screenshot with file persistence
const result = await mcp.tools.invoke("gowitness-screenshot", {
  url: "https://example.com",
  screenshot_path: "./my-screenshots"
});
```

#### Batch Screenshots

```javascript
// Multiple URLs at once
const result = await mcp.tools.invoke("gowitness-batch-screenshot", {
  urls: [
    "https://example.com",
    "https://google.com",
    "https://github.com"
  ],
  screenshot_path: "./batch-screenshots"
});
```

### Available Tools

- **`gowitness-screenshot`** - Capture single URL screenshots with extensive options
- **`gowitness-batch-screenshot`** - Process multiple URLs efficiently
- **`gowitness-list-screenshots`** - List saved screenshot files with metadata
- **`gowitness-read-binary`** - Read screenshot files as binary data
- **`gowitness-report`** - Generate reports from captured data

### Advanced Options

Gowitness MCP supports all standard gowitness parameters including:

- **Browser Settings**: Window dimensions, user agents, proxy configuration
- **Capture Options**: Full-page screenshots, custom delays, timeouts
- **Output Formats**: JPEG/PNG format selection
- **Data Persistence**: Database logging, JSON export
- **Performance**: Concurrent threading for batch operations

See the [gowitness documentation](https://github.com/sensepost/gowitness) for complete parameter details.

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Take screenshots of the main pages on example.com for documentation
AI: I'll capture screenshots of the main pages on example.com for you.

[AI uses Gowitness MCP to capture the screenshots]

I've successfully captured screenshots of:
- Homepage (example.com) - 1.2MB PNG
- About page (example.com/about) - 890KB PNG  
- Contact page (example.com/contact) - 756KB PNG

All screenshots have been saved to ./documentation-screenshots/
```

```
User: I need to document a suspicious website without saving files locally
AI: I'll capture the website and return the image data directly without saving files.

[AI uses binary return mode]

I've captured the website screenshot and returned it as binary data. The image shows...
[Analysis of the screenshot content]
```

## Storage Behavior

### Binary Mode (No Directory Specified)

- Returns screenshot as base64-encoded binary data
- Temporary files are automatically cleaned up
- Perfect for inline analysis and processing

### File Mode (Directory Specified)

- Saves screenshots to specified directory
- Files persist for later access and analysis
- Can optionally also return binary data

### Batch Mode

- Always saves to specified directory for organization
- Efficient concurrent processing of multiple URLs
- Comprehensive progress reporting

## Troubleshooting

If you encounter issues:

1. **"spawn gowitness ENOENT"**
    
    - Verify gowitness is installed: `gowitness --help`
    - Ensure gowitness is in your PATH
    - Try using absolute path in MCP configuration
2. **Screenshot capture failures**
    
    - Check URL accessibility and network connectivity
    - Verify target website allows automated access
    - Try increasing timeout and delay parameters
3. **Permission errors**
    
    - Ensure write permissions for screenshot directories
    - Check that Chrome/Chromium can be accessed by gowitness
4. **Binary return issues**
    
    - Use the file mode first to verify screenshots work
    - Then use list and read tools to access binary data
    - Check available files with `gowitness-list-screenshots`

## Acknowledgments

- Gowitness Project: https://github.com/sensepost/gowitness
- Model Context Protocol: https://github.com/modelcontextprotocol
- SensePost team for creating the excellent gowitness tool
```

--------------------------------------------------------------------------------
/httpx-mcp/readme.md:
--------------------------------------------------------------------------------

```markdown
# httpx MCP

> 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.

## Overview

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.

## Features

- Integration with httpx to scan for active HTTP and HTTPS services
- Support for multiple target domains in a single scan
- Customizable port scanning
- Extensive probing options for detailed web server analysis
- Technology detection based on the Wappalyzer dataset
- Response analysis including status codes, headers, and content
- Simple configuration and setup
- Easy integration with other MCP-compatible tools and systems
- Standardized input/output handling

## Installation

### Prerequisites

- Node.js (v16 or higher)
- httpx installed on your system
- MCP SDK

### Setup

1. Clone this repository:
 ```
 git clone https://github.com/cyproxio/mcp-for-security
 cd httpx-mcp
 ```

2. Install dependencies:
 ```
 npm install
 ```

3. Build the project:
 ```
 npm install && npm run build
 ```

## Usage

### Basic Configuration

Configure the httpx MCP server in your MCP client configuration:

```json
{
  "httpx": {
    "command": "node",
    "args": [
      "/path/to/httpx-mcp/build/index.js",
      "httpx"
    ]
  }
}
```

### Running httpx

Once configured, you can run httpx through the MCP interface using the `httpx` tool:

```javascript
// Example of calling httpx through MCP for a single domain
const result = await mcp.tools.invoke("httpx", {
  target: ["example.com"]
});

// Example of calling httpx with multiple targets and probes
const detailedResult = await mcp.tools.invoke("httpx", {
  target: ["example.com", "example.org", "example.net"],
  ports: ["80", "443", "8080", "8443"],
  probes: ["title", "status-code", "tech-detect", "web-server"]
});
```

## Parameters

httpx MCP supports the following parameters:

- `target`: A list of domain names to scan for HTTP and HTTPS services (required)
- `ports`: Custom ports to scan (optional, defaults to standard HTTP/HTTPS ports)
- `probes`: List of probe options to extract specific information (optional)

### Available Probe Options

- `status-code`: Display response status-code
- `content-length`: Display response content-length
- `content-type`: Display response content-type
- `location`: Display response redirect location
- `favicon`: Display mmh3 hash for '/favicon.ico' file
- `hash`: Display response body hash (supported: md5, mmh3, simhash, sha1, sha256, sha512)
- `jarm`: Display jarm fingerprint hash
- `response-time`: Display response time
- `line-count`: Display response body line count
- `word-count`: Display response body word count
- `title`: Display page title
- `body-preview`: Display first N characters of response body (default 100)
- `web-server`: Display server name
- `tech-detect`: Display technology in use based on wappalyzer dataset
- `method`: Display HTTP request method
- `websocket`: Display server using websocket
- `ip`: Display host IP
- `cname`: Display host CNAME
- `extract-fqdn`: Get domain and subdomains from response body and header
- `asn`: Display host ASN information
- `cdn`: Display CDN/WAF in use (default true)
- `probe`: Display probe status

## Examples

### Basic Scan of Multiple Domains

```javascript
const result = await mcp.tools.invoke("httpx", {
  target: ["example.com", "example.org", "example.net"]
});
```

### Scan with Custom Ports

```javascript
const result = await mcp.tools.invoke("httpx", {
  target: ["example.com"],
  ports: ["80", "443", "8080", "8443"]
});
```

### Comprehensive Web Technology Analysis

```javascript
const result = await mcp.tools.invoke("httpx", {
  target: ["example.com"],
  probes: ["tech-detect", "web-server", "title", "status-code", "content-type"]
});
```

### Extract Subdomains from Response

```javascript
const result = await mcp.tools.invoke("httpx", {
  target: ["example.com"],
  probes: ["extract-fqdn", "status-code"]
});
```

## Integration with AI Assistants

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.

Example conversation with an AI assistant:

```
User: Can you check what web technologies are used by example.com?
AI: I'll scan example.com to identify the web technologies in use.

[AI uses httpx MCP to scan the domain and returns the results]

I found the following technologies on example.com:
- Web Server: nginx/1.18.0
- Technologies: Bootstrap, jQuery, Google Analytics
- Status Code: 200 OK
- Title: Example Domain

Would you like me to analyze any other aspects of this website?
```

## Security Considerations

- This tool is intended for legitimate security research and testing
- Always obtain proper authorization before scanning websites
- Respect rate limits to avoid overwhelming target servers
- Use responsibly and ethically
- The tool only performs passive analysis of publicly available information

## Troubleshooting

If you encounter issues:

1. Verify httpx is properly installed and accessible
2. Check the path to the httpx executable in your configuration
3. Ensure proper permissions are set for execution
4. Review server logs for detailed error messages
5. For large scans, consider increasing timeouts or memory limits

## Usage Tips

- Combine httpx results with other reconnaissance tools for more comprehensive target information
- Use the tech-detect probe to quickly identify technologies that might have known vulnerabilities
- The extract-fqdn probe can help discover additional subdomains not found through other methods
- Use body-preview to get a quick glimpse of the response content without downloading everything
- The CDN detection can help identify which targets might be protected by WAFs

## Acknowledgments

- httpx Project: https://github.com/projectdiscovery/httpx
- Model Context Protocol: https://github.com/modelcontextprotocol
```

--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------

```markdown
# MCP for Security

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![Stars](https://img.shields.io/github/stars/cyproxio/mcp-for-security?style=social)](https://github.com/cyproxio/mcp-for-security/stargazers)
[![Docker](https://img.shields.io/github/release/cyproxio/mcp-for-security?style=social)](https://github.com/cyproxio/mcp-for-security/releases)
---

<img src="https://avatars.githubusercontent.com/u/89649708?s=48&v=4" width="40" align="left" />

**About Cyprox — The Future of AI-Driven Cybersecurity** <br/></br>


**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.  

> *"The Future of Cybersecurity Humans and AI, Working Together..."*

### Cyprox

- 🚀 **AI Driven Solutions:** Cybersecurity solutions using Agentic-AI systems with an AI-driven approach
- 🌐 **Community-Driven:** Open-source projects fostering collaboration and rapid evolution.
- ⚡ **Speed & Precision:** Automated threat detection that reduces human latency.
- 🔒 **Secure & Transparent:** Trustworthy platform built with open standards.

Explore more at [https://cyprox.io](https://cyprox.io)

---

## 🚀 Project Overview

**MCP for Security** repository contains Model Context Protocol (MCP) server implementations for various security testing tools, making them accessible through a standardized interface.

---

## 🌐 Installation 

### Docker

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.
Visit [Cyprox](https://cyprox.io) for more information.

### Manuel
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.

---


## Available Tools

| Tool | Description | Detailed Documentation |
|------|-------------|------------------------|
| Amass | Advanced subdomain enumeration and reconnaissance tool | [Amass MCP Documentation](./amass-mcp) |
| Alterx | Pattern-based wordlist generator for subdomain discovery | [Alterx MCP Documentation](./alterx-mcp/) |
| Arjun | Run Arjun to discover hidden HTTP parameters | [Arjun MCP Documentation](./arjun-mcp) |
| Assetfinder | Passive subdomain discovery tool based on Tomnomnom’s Assetfinder | [Assetfinder MCP Documentation](./assetfinder-mcp) |
| Cero | Certificate-based subdomain enumeration tool leveraging TLS handshakes to extract domain names from certificate fields like SAN | [Cero MCP Documentation](./cero-mcp) |
| Certificate Search (crt.sh) | Subdomain discovery tool using SSL certificate logs | [Certificate Search MCP Documentation](./crtsh-mcp/) |
| FFUF | Web content fuzzing tool for discovering hidden files and directories | [FFUF MCP Documentation](./ffuf-mcp/) |
| Gowitness | Web screenshot and reconnaissance tool for capturing and analyzing web pages | [Gowitness MCP Documentation](./gowitness-mcp/) |
| HTTP Headers Security | Analyzer for HTTP security headers against OWASP standards | [HTTP Headers MCP Documentation](./http-headers-security-mcp/) |
| httpx | Fast and multi-purpose HTTP toolkit for port scanning. | [httpx MCP Documentation](./httpx-mcp) |
| Katana | Fast and flexible web crawler with JS parsing and hybrid crawling support | [Katana MCP Documentation](./katana-mcp/) |
| Masscan | Fast port scanner for large-scale network discovery | [Masscan MCP Documentation](./masscan-mcp/) |
| MobSF | Mobile security framework for analyzing mobile applications | [MobSF MCP Documentation](./mobsf-mcp/) |
| Nmap | Comprehensive network scanning tool for service and vulnerability discovery | [Nmap MCP Documentation](./nmap-mcp/) |
| Nuclei | Vulnerability scanner using custom templates | [Nuclei MCP Documentation](./nuclei-mcp/) |
| Scout Suite | Cloud security auditing tool for assessing configurations across multiple services | [Scout Suite MCP Documentation](./scoutsuite-mcp/) |
| SSLScan | SSL/TLS configuration analyzer for security assessment | [SSLScan MCP Documentation](./sslscan-mcp/) |
| shuffledns | High-speed and customizable DNS brute-forcing and resolution tool | [shuffledns MCP Documentation](./shuffledns-mcp) |
| Smuggler | Advanced tool for detecting HTTP Request Smuggling vulnerabilities | [Smuggler MCP Documentation](./smuggler-mcp) |
| SQLmap | Advanced SQL injection detection and exploitation tool | [SQLmap MCP Documentation](./sqlmap-mcp/) |
| Waybackurls | Tool for retrieving historical URLs from the Wayback Machine | [Waybackurls MCP Documentation](./waybackurls-mcp/) |
| WPScan | WordPress vulnerability scanner for detecting plugins, themes, and configuration issues | [WPScan MCP Documentation](./wpscan-mcp/) |

## Quick Reference

### Alterx MCP  
Generates custom wordlists for subdomain discovery using pattern-based permutations.

### Amass MCP  
Advanced reconnaissance tool for subdomain enumeration and intelligence gathering with both passive and active modes.

### arjun MCP  
Discovers hidden HTTP parameters on web applications by scanning URLs, supporting custom wordlists, multiple methods, and adjustable scanning speeds.

### Assetfinder MCP
Discovers subdomains related to a given domain using passive enumeration techniques. Integrates Tomnomnom’s Assetfinder into the MCP ecosystem for fast and reliable reconnaissance.

### Cero MCP Server
Certificate-based subdomain discovery tool that extracts domain names from TLS certificates for reconnaissance and infrastructure mapping.

### Certificate Search (crt.sh) MCP  
Discovers subdomains by querying SSL certificate transparency logs without active scanning.

### FFUF MCP Server  
URL-based fuzzing tool with support for all FFUF command line arguments.

### Gowitness MCP Server  
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.

### HTTP Headers Security MCP  
Analyzes HTTP response headers against OWASP security standards with recommendations.

### httpx MCP  
Performs high-speed probing of discovered subdomains to validate alive hosts, fetch response details, and enrich reconnaissance data without heavy scanning.

### Katana MCP 
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.

### Masscan MCP Server  
Fast port scanning tool for target-based port discovery across networks.

### MobSF MCP Server  
Mobile application security testing framework for Android, iOS, and Windows applications.

### Nmap MCP Server  
Full-featured network scanner with detailed service fingerprinting and vulnerability detection.

### Nuclei MCP Server  
Template-based vulnerability scanner with an extensive library of security checks.

### Scout Suite MCP Server 
Performs a multi-service cloud security audit by analyzing cloud configurations and highlighting potential misconfigurations and risks based on best practices.

### shuffledns MCP  
High-speed DNS brute-forcing and mass subdomain resolution tool to quickly discover valid subdomains using custom resolvers and wordlists.

### smuggler MCP  
HTTP Request Smuggling detection tool that identifies desynchronization vulnerabilities between front-end and back-end servers.

### SQLmap MCP Server  
SQL injection testing tool with comprehensive capabilities for vulnerability discovery.

### SSLScan MCP Server  
SSL/TLS configuration analyzer for identifying weak ciphers and security misconfigurations.

### Waybackurls MCP  
Retrieves historical URLs from the Wayback Machine to discover forgotten endpoints.

### WPScan MCP  
WordPress vulnerability scanner for detecting outdated plugins, themes, and common misconfigurations.


## TO-DO Tools 
- commix
- Corsy
- CrackMapExec
- crlfuzz
- dalfox
- dnsrecon
- feroxbuster
- gau
- getJS
- github-endpoints
- github-subdomains
- gobuster
- gospider
- hakrawler
- kiterunner
- medusa
- naabu
- ParamSpider
- puredns
- s3scanner
- tlsx
- wafw00f
- webscreenshot
- wpscan
- ...

## Development

The project uses TypeScript and the Model Context Protocol SDK. To contribute:

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request

## Installation

For installation instructions for each tool, please refer to the individual documentation linked in the table above.

## Usage

Each tool has specific parameters and usage instructions. For detailed information, see the documentation for the specific tool you want to use.


```

--------------------------------------------------------------------------------
/mobsf-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

npm install && npm run build
```

--------------------------------------------------------------------------------
/shuffledns-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

npm install && npm run build
```

--------------------------------------------------------------------------------
/sslscan-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

npm install && npm run build
```

--------------------------------------------------------------------------------
/smuggler-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./build",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "build"]
} 
```

--------------------------------------------------------------------------------
/ffuf-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "ffuf-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.2"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "zod": "^3.24.2"
  }
}

```

--------------------------------------------------------------------------------
/nmap-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "nmap-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.2"
  }
}

```

--------------------------------------------------------------------------------
/alterx-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "alterx-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.9.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.1",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/amass-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "amass-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.0",
    "zod": "^3.24.3"
  },
  "devDependencies": {
    "@types/node": "^22.15.3",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/sqlmap-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "sqlmap-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.2"
  }
}

```

--------------------------------------------------------------------------------
/arjun-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "arjun-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.1",
    "zod": "^3.24.4"
  },
  "devDependencies": {
    "@types/node": "^22.15.17",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/masscan-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "masscan-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.2"
  }
}

```

--------------------------------------------------------------------------------
/sslscan-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "sslscan-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/wpscan-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "wpscan-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.12.2",
    "zod": "^3.25.64"
  },
  "devDependencies": {
    "@types/node": "^24.0.1",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/waybackurls-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "waybackurls-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.9.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/gowitness-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "gowitness-mcp",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "dev": "tsx src/index.ts",
    "start": "node build/index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.17.2",
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "tsx": "^4.0.0",
    "typescript": "^5.0.0"
  }
}

```

--------------------------------------------------------------------------------
/mobsf-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "mobsf-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "axios": "^1.8.4",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.2"
  }
}

```

--------------------------------------------------------------------------------
/commix-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "commix-mcp",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.15.1",
    "zod": "^3.25.76"
  },
  "devDependencies": {
    "@types/node": "^24.0.13",
    "typescript": "^5.8.3"
  }
}
```

--------------------------------------------------------------------------------
/httpx-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "httpx-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.0",
    "node-pty": "^1.0.0",
    "zod": "^3.24.3"
  },
  "devDependencies": {
    "@types/node": "^22.15.3",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/nuclei-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "nuclei-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "node-pty": "^1.0.0",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/katana-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "katana-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.4",
    "node-pty": "^1.0.0",
    "zod": "^3.25.3"
  },
  "devDependencies": {
    "@types/node": "^22.15.19",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/scoutsuite-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "scoutsuite-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.4",
    "node-pty": "^1.0.0",
    "zod": "^3.25.7"
  },
  "devDependencies": {
    "@types/node": "^22.15.20",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/shuffledns-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "shuffledns-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "devDependencies": {
    "@types/node": "^22.15.12",
    "typescript": "^5.8.3"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.0",
    "node-pty": "^1.0.0",
    "zod": "^3.24.4"
  }
}

```

--------------------------------------------------------------------------------
/assetfinder-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "assetfinder-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.4",
    "node-pty": "^1.0.0",
    "zod": "^3.25.7"
  },
  "devDependencies": {
    "@types/node": "^22.15.19",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/http-headers-security-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "http-headers-security-mcp",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.9.0",
    "axios": "^1.8.4",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.14.0",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/smuggler-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "smuggler-mcp",
  "version": "1.0.0",
  "description": "MCP wrapper for HTTP Request Smuggling testing tool",
  "main": "build/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node build/index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.2",
    "zod": "^3.21.4"
  },
  "devDependencies": {
    "typescript": "^5.0.4",
    "@types/node": "^18.11.9"
  }
} 
```

--------------------------------------------------------------------------------
/cero/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "cero",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.15.1",
    "node-pty": "^1.0.0",
    "zod": "^3.25.76"
  },
  "devDependencies": {
    "@types/node": "^24.0.12",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/alterx-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/amass-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/crtsh-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/ffuf-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/httpx-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/masscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/mobsf-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/nmap-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/nuclei-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/shuffledns-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/sqlmap-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/sslscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/waybackurls-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}
```

--------------------------------------------------------------------------------
/arjun-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/assetfinder-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/cero/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/commix-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/katana-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/scoutsuite-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/wpscan-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

```

--------------------------------------------------------------------------------
/gowitness-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./build",
    "rootDir": "./src",
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "build"]
} 
```

--------------------------------------------------------------------------------
/crtsh-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/tsconfig.json:
--------------------------------------------------------------------------------

```json
{
    "compilerOptions": {
        "target": "ES2022",
        "module": "Node16",
        "moduleResolution": "Node16",
        "outDir": "./build",
        "rootDir": "./src",
        "strict": true,
        "esModuleInterop": true,
        "skipLibCheck": true,
        "forceConsistentCasingInFileNames": true,
        "resolveJsonModule": true
    },
    "include": [
        "src/**/*",
        "src/owasp_headers_remove.json",
        "src/owasp_headers_add.json"
    ],
    "exclude": [
        "node_modules"
    ]

}
```

--------------------------------------------------------------------------------
/crtsh-mcp/package.json:
--------------------------------------------------------------------------------

```json
{
  "name": "crtsh-mcp",
  "version": "1.0.0",
  "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.",
  "main": "index.js",
  "scripts": {
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.0",
    "zod": "^3.24.3"
  },
  "devDependencies": {
    "@types/node": "^22.15.3",
    "typescript": "^5.8.3"
  }
}

```

--------------------------------------------------------------------------------
/nmap-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
NMAP_PATH=$(which nmap)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$NMAP_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/masscan-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
MASSCAN_PATH=$(which masscan)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$MASSCAN_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/ffuf-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

go install github.com/ffuf/ffuf@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
FFUF_PATH=$(which ffuf)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$FFUF_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/cero/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

go install github.com/glebarez/cero@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
CERO_PATH=$(which cero)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$CERO_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/scoutsuite-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

source /opt/venv/bin/activate
pip install scoutsuite

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
SCOUT_PATH=$(which scout)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$SCOUT_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/amass-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

go install github.com/owasp-amass/amass/v4/...@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
AMASS_PATH=$(which amass)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg amass_path "$AMASS_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $amass_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/wpscan-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

# Ensure wpscan is installed
[ -x "$(which wpscan)" ] || gem install wpscan >/dev/null 

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg index_path "$INDEX_PATH" \
   --arg bin_name "wpscan" \
   '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/gowitness-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

go install github.com/sensepost/gowitness@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
GOWITNESS_PATH=$(which gowitness)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$GOWITNESS_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/httpx-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

go install github.com/projectdiscovery/httpx/cmd/httpx@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
HTTPX_PATH=$(which httpx)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$HTTPX_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/katana-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

go install github.com/projectdiscovery/katana/cmd/katana@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
KATANA_PATH=$(which katana)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$KATANA_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/assetfinder-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

go install github.com/tomnomnom/assetfinder@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
ASSETFINDER_PATH=$(which assetfinder)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$ASSETFINDER_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/nuclei-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
NUCLEI_PATH=$(which nuclei)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg bin_path "$NUCLEI_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $bin_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/sqlmap-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

# Ensure sqlmap is installed and available in PATH
SQLMAP_BIN=$(which sqlmap)
[ -x "$SQLMAP_BIN" ] || exit 1

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg index_path "$INDEX_PATH" \
   --arg bin_name "sqlmap" \
   '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/waybackurls-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null
npm run build >/dev/null 

go install github.com/tomnomnom/waybackurls@latest

WAYBACK_BIN=$(which waybackurls)
[ -x "$WAYBACK_BIN" ] || exit 1

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg index_path "$INDEX_PATH" \
   --arg bin_name "waybackurls" \
   '.[$cmd] = { "command": "node", "args": [$index_path, $bin_name] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/arjun-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 2>&1
npm run build >/dev/null 2>&1

# Activate shared venv (defined in Dockerfile)
source /opt/venv/bin/activate

pip install arjun >/dev/null 

SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
ARJUN_PATH=$(which arjun)
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg arjun_path "$ARJUN_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $arjun_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/start.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

echo "[*] Starting all services..."

# Loop through all directories in the current folder
for dir in */ ; do
    # Remove trailing slash
    dir=${dir%/}

    # Skip if not a directory
    [ -d "$dir" ] || continue

    # Check if build.sh exists in the directory
    if [ -f "$dir/build.sh" ]; then
        echo "[+] Found build.sh in $dir, executing..."
        chmod +x "$dir/build.sh"
        (cd "$dir" && ./build.sh)
    else
        echo "[-] No build.sh found in $dir, skipping..."
    fi
done

jq '{mcpServers: with_entries(.value += {dockerContainer: ""})}' mcp-config.json > mcp-config.tmp && mv mcp-config.tmp mcp-config.json

echo "[*] All build scripts executed. Container will now remain running."

cat mcp-config.json
```

--------------------------------------------------------------------------------
/smuggler-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

# Clone Smuggler if not already present
[ -d "/opt/smuggler" ] || git clone https://github.com/defparam/smuggler /opt/smuggler

PYTHON_PATH=$(which python3)
SMUGGLER_PATH="/opt/smuggler/smuggler.py"
SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

[ -f "$SMUGGLER_PATH" ] || exit 1
[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"

jq --arg cmd "$COMMAND_NAME" \
   --arg index_path "$INDEX_PATH" \
   --arg py_path "$PYTHON_PATH" \
   --arg smuggler_path "$SMUGGLER_PATH" \
   '.[$cmd] = { "command": "node", "args": [$index_path, $py_path, $smuggler_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/commix-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install >/dev/null 
npm run build >/dev/null 

# Clone Smuggler if not already present
[ -d "/opt/commix" ] || git clone https://github.com/commixproject/commix.git /opt/commix

PYTHON_PATH=$(which python3)
COMMIX_PATH="/opt/commix/commix.py"
SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"
COMMAND_NAME=$(basename "$SERVICE_PATH")
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"
echo $COMMIX_PATH
[ -f "$COMMIX_PATH" ] || exit 1
[ -f "$CONFIG_FILE" ] || echo "{}" > "$CONFIG_FILE"


jq --arg cmd "$COMMAND_NAME" \
   --arg index_path "$INDEX_PATH" \
   --arg py_path "$PYTHON_PATH" \
   --arg commix_path "$COMMIX_PATH" \
   '.[$cmd] = { "command": "node", "args": [$index_path, $py_path, $commix_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/alterx-mcp/build.sh:
--------------------------------------------------------------------------------

```bash
#!/bin/bash

set -e

npm install && npm run build

go install github.com/projectdiscovery/alterx/cmd/alterx@latest

# Get absolute path to this directory and index.js
SERVICE_PATH=$(pwd)
INDEX_PATH="$SERVICE_PATH/build/index.js"

# Get full path to the 'alterx' binary
ALTERX_PATH=$(which alterx)

# Set dynamic command name (folder name is a good default)
COMMAND_NAME=$(basename "$SERVICE_PATH")

# Output config file
CONFIG_FILE="$SERVICE_PATH/../mcp-config.json"

# Ensure mcp-config.json exists (if not, initialize it)
if [ ! -f "$CONFIG_FILE" ]; then
    echo "{}" > "$CONFIG_FILE"
fi


jq --arg cmd "$COMMAND_NAME" \
   --arg node_path "$INDEX_PATH" \
   --arg alterx_path "$ALTERX_PATH" \
   '.[$cmd] = { "command": "node", "args": [$node_path, $alterx_path] }' \
   "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
```

--------------------------------------------------------------------------------
/.github/workflows/docker.yml:
--------------------------------------------------------------------------------

```yaml
name: Manual Docker Build and Push with Release

on:
  workflow_dispatch:
    inputs:
      tag:
        description: 'Docker image tag (default: latest)'
        required: false
        default: 'latest'

jobs:
  build-and-release:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Docker Push
        uses: docker/build-push-action@v2
        with:
          username: cyprox
          password: ${{secrets.CYPROX_DOCKER_HUB_PASSWORD}}
          repository: cyprox/mcp-for-security
          tags: ${{ github.event.inputs.tag }}

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v1
        with:
          tag_name: ${{ github.event.inputs.tag }}
          name: MCP Docker Image - ${{ github.event.inputs.tag }}
          body: |
            Docker image published to Docker Hub:
            `docker pull cyprox/mcp-for-security:${{ github.event.inputs.tag }}`
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```

--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------

```dockerfile
FROM golang:1.24-bullseye AS golang

# Set working directory
WORKDIR /app



# Install Python, pip, Go, virtualenv, and other tools
RUN apt-get update && apt-get install -y --no-install-recommends \
    python3 \
    python3-pip \
    python3-venv \
    jq \
    curl \
    git \
    masscan \
    nmap \
    ruby-full && \
    apt-get clean && rm -rf /var/lib/apt/lists/* && \
    git clone https://github.com/sqlmapproject/sqlmap /opt/sqlmap && \
    ln -s /opt/sqlmap/sqlmap.py /usr/local/bin/sqlmap && \
    chmod +x /usr/local/bin/sqlmap


    RUN curl -fsSL https://deb.nodesource.com/setup_24.x | bash - && \
    apt-get install -y nodejs && \
    if ! command -v npm >/dev/null 2>&1; then \
        echo "[*] npm not found, installing manually..."; \
        apt-get install -y npm; \
    else \
        echo "[+] npm is already included with Node.js"; \
    fi && \
    npm install -g npm@latest \ 
    npm install -g @cyproxio/mcp-manager

# Create a global virtualenv
RUN python3 -m venv /opt/venv

# Install pip tools inside venv if needed (optional)
RUN /opt/venv/bin/pip install --upgrade pip

# Add venv to PATH (so pip, python point to venv by default)
ENV PATH="/opt/venv/bin:$PATH"

# Copy project files
COPY . .

# Make sure the entrypoint is executable
COPY start.sh /app/start.sh
RUN chmod +x /app/start.sh && /app/start.sh

RUN cat mcp-config.json
CMD ["bash"]

```

--------------------------------------------------------------------------------
/crtsh-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { GetCrtSh } from './crtsh'

const args = process.argv.slice(1);
if (args.length === 0) {
    console.error("Usage: crtsh-mcp");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "crtsh",
    version: "1.0.0",
});

server.tool(
    "crtsh",
    "Discovers subdomains from SSL certificate logs",
    {
        target: z.string().describe("Target domain to analyze (e.g., example.com)."),
    },
    async ({ target }) => {
        return new Promise((resolve, reject) => {
            GetCrtSh(target)
                .then(async domains => {
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: JSON.stringify(domains, null, 2)
                        }]
                    }
                    resolve(resolveData);
                })
                .catch(error => {
                    reject(error);
                });
        });
    }
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("crtsh MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/scoutsuite-mcp/src/parser.ts:
--------------------------------------------------------------------------------

```typescript
const fs = require('fs');
const vm = require('vm');

interface Findings {
    [key: string]: any;
}

interface ServiceData {
    filters?: object;
    findings?: Findings;
    [key: string]: any;
}

interface ScoutSuiteResults {
    services: {
        [serviceName: string]: ServiceData;
    };
}

type FullReportResult = Record<string, Findings>;
type SummaryReportResult = Record<string, string[]>;

function getFindingsFromScoutSuite(
    filePath: string,
    full_report: true
): FullReportResult;
function getFindingsFromScoutSuite(
    filePath: string,
    full_report: false
): SummaryReportResult;
function getFindingsFromScoutSuite(
    filePath: string,
    full_report: boolean
): FullReportResult | SummaryReportResult {
    const fileContent = fs.readFileSync(filePath, 'utf-8');

    const context: Record<string, any> = {};
    vm.createContext(context);
    vm.runInContext(fileContent, context);

    const results: ScoutSuiteResults = context.scoutsuite_results;
    const services = results.services;

    const servicesWithFindings: FullReportResult | SummaryReportResult = {};

    for (const [serviceName, serviceData] of Object.entries(services)) {
        if (
            serviceData.findings &&
            Object.keys(serviceData.findings).length > 0
        ) {
            servicesWithFindings[serviceName] = full_report
                ? serviceData.findings
                : Object.keys(serviceData.findings);
        }
    }

    return servicesWithFindings;
}

function extractReportJsPath(output: string): string | null {
    const regex = /Saving data to (scoutsuite-report\/scoutsuite-results\/scoutsuite_results_[\w\-]+\.js)/;
    const match = output.match(regex);
    return match ? match[1] : null;
}


module.exports = { getFindingsFromScoutSuite,extractReportJsPath };
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/src/owasp_headers_add.json:
--------------------------------------------------------------------------------

```json
{
    "headers": [
        {
            "name": "Cache-Control",
            "value": "no-store, max-age=0"
        },
        {
            "name": "Clear-Site-Data",
            "value": "\"cache\",\"cookies\",\"storage\""
        },
        {
            "name": "Content-Security-Policy",
            "value": "default-src 'self'; form-action 'self'; base-uri 'self'; object-src 'none'; frame-ancestors 'none'; upgrade-insecure-requests; block-all-mixed-content"
        },
        {
            "name": "Cross-Origin-Embedder-Policy",
            "value": "require-corp"
        },
        {
            "name": "Cross-Origin-Opener-Policy",
            "value": "same-origin"
        },
        {
            "name": "Cross-Origin-Resource-Policy",
            "value": "same-origin"
        },
        {
            "name": "Permissions-Policy",
            "value": "accelerometer=(), autoplay=(), camera=(), cross-origin-isolated=(), display-capture=(), encrypted-media=(), fullscreen=(), geolocation=(), gyroscope=(), keyboard-map=(), magnetometer=(), microphone=(), midi=(), payment=(), picture-in-picture=(), publickey-credentials-get=(), screen-wake-lock=(), sync-xhr=(self), usb=(), web-share=(), xr-spatial-tracking=(), clipboard-read=(), clipboard-write=(), gamepad=(), hid=(), idle-detection=(), interest-cohort=(), serial=(), unload=()"
        },
        {
            "name": "Referrer-Policy",
            "value": "no-referrer"
        },
        {
            "name": "Strict-Transport-Security",
            "value": "max-age=31536000; includeSubDomains"
        },
        {
            "name": "X-Content-Type-Options",
            "value": "nosniff"
        },
        {
            "name": "X-Frame-Options",
            "value": "deny"
        },
        {
            "name": "X-Permitted-Cross-Domain-Policies",
            "value": "none"
        }
    ]
}
```

--------------------------------------------------------------------------------
/crtsh-mcp/src/crtsh.ts:
--------------------------------------------------------------------------------

```typescript
interface CrtShResponse {
    issuer_ca_id: number;
    issuer_name: string;
    common_name: string;
    name_value: string;
    id: number;
    entry_timestamp: string;
    not_before: string;
    not_after: string;
    serial_number: string;
    result_count: number;
}


export async function GetCrtSh(target: string): Promise<string[]> {
    const subdomains = await sendReqCrtSh(target);
    var results  = ClearResult(subdomains,target)
    return results;
}

async function sendReqCrtSh(query: string): Promise<string[]> {
    try {
        const response = await fetch(`https://crt.sh/?q=${query}&output=json`);

        if (!response.ok) {
            return [];
        }

        const crtshResponse: CrtShResponse[] = await response.json();
        const domains: string[] = [];

        for (const crtshResp of crtshResponse) {
            // NameValue'yi parse et ve domains array'ine ekle
            const nameValues = parseNameValue(crtshResp.name_value);
            domains.push(...nameValues);
        }

        return domains;
    } catch (error) {
        console.error("Error fetching from crt.sh:", error);
        return [];
    }
}

function parseNameValue(nameValue: string): string[] {
    // \n karakterine göre böl
    const values = nameValue.split("\n");

    // Boş değerleri filtrele
    const result = values.filter(v => v !== "");

    return result;
}

function ClearResult(result: string[], name: string): string[] {
   
    const escapedName = name.replace(/\./g, "\\.");

    
    const re = new RegExp(`[^.]+\\.${escapedName}\\b`);

    const unique: { [key: string]: boolean } = {};
    const uniqueList: string[] = [];

    
    for (const val of result) {
        if (!unique[val]) {
            if (re.test(val)) {
                unique[val] = true;
                uniqueList.push(val);
            }
        }
    }

    return uniqueList;
}
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/src/owasp_headers_remove.json:
--------------------------------------------------------------------------------

```json
{
    "headers": [
        "$wsep",
        "Host-Header",
        "K-Proxy-Request",
        "Liferay-Portal",
        "OracleCommerceCloud-Version",
        "Pega-Host",
        "Powered-By",
        "Product",
        "Server",
        "SourceMap",
        "X-AspNet-Version",
        "X-AspNetMvc-Version",
        "X-Atmosphere-error",
        "X-Atmosphere-first-request",
        "X-Atmosphere-tracking-id",
        "X-B3-ParentSpanId",
        "X-B3-Sampled",
        "X-B3-SpanId",
        "X-B3-TraceId",
        "X-BEServer",
        "X-Backside-Transport",
        "X-CF-Powered-By",
        "X-CMS",
        "X-CalculatedBETarget",
        "X-Cocoon-Version",
        "X-Content-Encoded-By",
        "X-DiagInfo",
        "X-Envoy-Attempt-Count",
        "X-Envoy-External-Address",
        "X-Envoy-Internal",
        "X-Envoy-Original-Dst-Host",
        "X-Envoy-Upstream-Service-Time",
        "X-FEServer",
        "X-Framework",
        "X-Generated-By",
        "X-Generator",
        "X-Jitsi-Release",
        "X-Joomla-Version",
        "X-Kubernetes-PF-FlowSchema-UI",
        "X-Kubernetes-PF-PriorityLevel-UID",
        "X-LiteSpeed-Cache",
        "X-LiteSpeed-Purge",
        "X-LiteSpeed-Tag",
        "X-LiteSpeed-Vary",
        "X-Litespeed-Cache-Control",
        "X-Mod-Pagespeed",
        "X-Nextjs-Cache",
        "X-Nextjs-Matched-Path",
        "X-Nextjs-Page",
        "X-Nextjs-Redirect",
        "X-OWA-Version",
        "X-Old-Content-Length",
        "X-OneAgent-JS-Injection",
        "X-Page-Speed",
        "X-Php-Version",
        "X-Powered-By",
        "X-Powered-By-Plesk",
        "X-Powered-CMS",
        "X-Redirect-By",
        "X-Server-Powered-By",
        "X-SourceFiles",
        "X-SourceMap",
        "X-Turbo-Charged-By",
        "X-Umbraco-Version",
        "X-Varnish-Backend",
        "X-Varnish-Server",
        "X-dtAgentId",
        "X-dtHealthCheck",
        "X-dtInjectedServlet",
        "X-ruxit-JS-Agent"
    ]
}
```

--------------------------------------------------------------------------------
/commix-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length !== 2) {
    console.error("Usage: commix-mcp [python path] [commix.py path]");
    process.exit(1);
}

const server = new McpServer({
    name: "commix",
    version: "1.0.0",
});

server.tool(
    "do-commix",
    "Run Smuggler to detect HTTP Request Smuggling vulnerabilities",
    {
        url: z.string().url().describe("Target URL to detect HTTP Request Smuggling")
    },
    async ({ url }) => {
        const baseArgs = [args[1],"-u", url];
        const allArgs = [...baseArgs, url];
        let output = '';

        const commix = spawn(args[0],allArgs);

        commix.stdout.on('data', (data) => {
            output += data.toString();
        });

        commix.stderr.on('data', (data) => {
            output += data.toString();
        });

        return new Promise((resolve, reject) => {
            commix.on('close', (code) => {
                if (code === 0) {
                    output = removeAnsiCodes(output);
                    
                    resolve({
                        content: [{
                            type: "text",
                            text: output
                        }]
                    });
                } else {
                    reject(new Error(`commix exited with code ${code}`));
                }
            });
            
            commix.on('error', (error) => {
                reject(new Error(`Failed to start commix: ${error.message}`));
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*[mGK]/g, '');
}

async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("Smuggler MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
}); 
```

--------------------------------------------------------------------------------
/masscan-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: masscan <masscan binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "masscan",
    version: "1.0.0",
});

server.tool(
    "do-masscan",
    "Run masscan with specified target MASSCAN is a fast port scanner. The primary input parameters are the IP addresses/ranges you want to scan, and the port numbers.",
    {
        target: z.string().describe(`Target information. Example: 1.1.1.1
            1.1.1.1
            `),
        port: z.string().describe(`Target port. Example: 1234
               0-65535
                `),
        masscan_args: z.array(z.string()).describe(`Additional masscan arguments 
            --max-rate 
            `),
    },
    async ({ target, port,masscan_args }) => {
        const masscan = spawn(args[0], ["-p" + port, target, ...masscan_args]);
        let output = '';

        // Handle stdout
        masscan.stdout.on('data', (data) => {
            output += data.toString();
        });

        // Handle stderr
        masscan.stderr.on('data', (data) => {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            masscan.on('close', (code) => {
                if (code === 0) {
                    resolve({
                        content: [{
                            type: "text",
                            text: output + "\n masscan completed successfully"
                        }]
                    });
                } else {
                    reject(new Error(`masscan exited with code ${code}`));
                }
            });

            masscan.on('error', (error) => {
                reject(new Error(`Failed to start masscan: ${error.message}`));
            });
        });
    },
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("Masscan MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/assetfinder-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const z = require('zod');
const pty = require('node-pty');
const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: assetfinder-mcp <assetfinder binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "assetfinder",
    version: "1.0.0",
});

server.tool(
    "do-assetfinder",
    "Find related domains and subdomains using assetfinder for a given target.",
    {
        target: z.string().describe("The root domain (e.g., example.com) to discover associated subdomains and related domains."),
    },
    async ({ target }) => {

        const assetfinderArgs = ["-subs-only", target];
        let output = "";
        const assetfinder = pty.spawn(args[0], assetfinderArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        assetfinder.on('data', function (data: string) {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            assetfinder.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`assetfinder exited with code ${code}`));
                }
            });
            assetfinder.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start assetfinder: ${error.cause}`));
                }
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("assetfinder MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/waybackurls-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: waybackurls-mcp <waybackurls binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "waybackurls",
    version: "1.0.0",
});

server.tool(
    "do-waybackurls",
    "Execute Waybackurls, a tool that fetches known URLs from the Wayback Machine archive for a given domain. This helps in discovering historical endpoints, forgotten API paths, and potentially vulnerable URLs that might not be directly accessible or linked from the current version of the website.",
    {
        target: z.string().url().describe("Target domain to retrieve historical URLs from the Wayback Machine (e.g., example.com)"),
        noSub: z.boolean().nullable().describe("When set to true, only retrieves URLs from the exact domain specified, excluding all subdomains"),
    },
    async ({ target, noSub }) => {
        const waybackurls = spawn(args[0], [target, ...(noSub ? ['--no-subs'] : [])]);

        let output = '';

        // Handle stdout
        waybackurls.stdout.on('data', (data: Buffer) => {
            output += data.toString();
        });

        // Handle stderr
        waybackurls.stderr.on('data', (data) => {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            waybackurls.on('close', (code) => {
                if (code === 0) {
                    resolve({
                        content: [{
                            type: "text",
                            text: output + "\n waybackurls completed successfully"
                        }]
                    });
                } else {
                    reject(new Error(`waybackurls exited with code ${code}`));
                }
            });

            waybackurls.on('error', (error) => {
                reject(new Error(`Failed to start waybackurls: ${error.message}`));
            });
        });
    },
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("waybackurls MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/shuffledns-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const pty = require('node-pty');

const args = process.argv.slice(2);
if (args.length < 2) {
    console.error("Usage: shuffledns-mcp <shuffledns binary> <massdns binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "shuffledns",
    version: "1.0.0",
});

server.tool(
    "shuffledns",
    "DNS Brute force",
    {
        target: z.string().describe("A list of domain names (e.g., example.com) to scan for HTTP and HTTPS services."),
        resolver: z.string().describe("Resolver file path"),
        mode: z.enum(["bruteforce", "resolve", "filter"]).describe("Mode"),
        wordlist: z.string().describe("wordlist"),
        rateLimit: z.number().optional().describe("ratelimit")
    },
    async ({ target, resolver, mode, wordlist, rateLimit }) => {
        const shufflednsArgs = ["-d", target, "-r", resolver, "-mode", mode, "-w", wordlist, "-m", args[1],"-silent"];
        if (rateLimit) {
            shufflednsArgs.push("-t", rateLimit.toString());
        }
        let output = '';
        const shuffledns = pty.spawn(args[0], shufflednsArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        shuffledns.on('data', function (data: string) {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            shuffledns.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`shuffledns exited with code ${code}`));
                }
            });
            shuffledns.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start shuffledns: ${error.cause}`));
                }
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("shuffledns MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/smuggler-mcp/mcp.json:
--------------------------------------------------------------------------------

```json
{
  "name": "smuggler",
  "version": "1.0.0",
  "description": "HTTP Request Smuggling / Desync testing tool",
  "tools": [
    {
      "name": "do-smuggler",
      "description": "Run Smuggler to detect HTTP Request Smuggling vulnerabilities",
      "input_schema": {
        "type": "object",
        "required": ["url"],
        "properties": {
          "url": {
            "type": "string",
            "description": "Target URL to detect HTTP Request Smuggling"
          },
          "smuggler_args": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Additional smuggler arguments\n        -m, --method METHOD  Specify the HTTP method to use (default: POST)\n        -v, --vhost VHOST    Specify a virtual host to use\n        -l, --len            Enable Content-Length header in all requests\n        -c, --configfile FILE\n                             Specify a configuration file to load payloads from\n        -x                   Exit on the first finding\n        -t, --timeout TIMEOUT\n                             Socket timeout value (default: 5)\n        -verify VERIFY       Verify findings with more requests; never, quick or thorough (default: quick)"
          }
        }
      },
      "output_schema": {
        "type": "object",
        "properties": {
          "content": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": ["text"]
                },
                "text": {
                  "type": "string"
                }
              }
            }
          },
          "metadata": {
            "type": "object",
            "properties": {
              "findings": {
                "type": "object",
                "properties": {
                  "cl_te": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "mutation": {
                          "type": "string"
                        },
                        "severity": {
                          "type": "string",
                          "enum": ["high", "medium", "low"]
                        }
                      }
                    }
                  },
                  "te_cl": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "mutation": {
                          "type": "string"
                        },
                        "severity": {
                          "type": "string",
                          "enum": ["high", "medium", "low"]
                        }
                      }
                    }
                  }
                }
              },
              "raw_output": {
                "type": "string"
              }
            }
          }
        }
      }
    }
  ]
} 
```

--------------------------------------------------------------------------------
/arjun-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: arjun-mcp <arjun binary or python3 arjun>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "arjun",
    version: "1.0.0",
});

server.tool(
    "do-arjun",
    "Run Arjun to discover hidden HTTP parameters",
    {
        url: z.string().url().describe("Target URL to scan for hidden parameters"),
        textFile: z.string().optional().describe("Path to file containing multiple URLs"),
        wordlist: z.string().optional().describe("Path to custom wordlist file"),
        method: z.enum(["GET", "POST", "JSON", "HEADERS"]).optional().describe("HTTP method to use for scanning (default: GET)"),
        rateLimit: z.number().optional().describe("Maximum requests per second (default: 9999)"),
        chunkSize: z.number().optional().describe("Chunk size. The number of parameters to be sent at once"),

    },
    async ({ url, textFile, wordlist, method, rateLimit,chunkSize }) => {
        // Build command arguments
        const arjunArgs = []

        if (!url && !textFile) {
            throw new Error("url or textfile parameter required");
        }
        if (url) {
            arjunArgs.push('-u', url);
        }
        if (textFile) {
            arjunArgs.push('-f', textFile);
        }
        if (wordlist) {
            arjunArgs.push('-w', wordlist);
        }
        if (method) {
            arjunArgs.push('-m', method);
        }
        if (rateLimit) {
            arjunArgs.push('--rate-limit', rateLimit.toString());
        }
        if (chunkSize){
            arjunArgs.push('--rate-limit', chunkSize.toString());
        }
        

        const arjun = spawn(args[0], arjunArgs);
        let output = '';
        // Handle stdout
        arjun.stdout.on('data', (data) => {
            output += data.toString();
        });

        // Handle stderr
        arjun.stderr.on('data', (data) => {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            arjun.on('close', (code) => {
                if (code === 0) {
                    resolve({
                        content: [{
                            type: "text",
                            text: output
                        }]
                    });
                } else {
                    reject(new Error(`arjun exited with code ${code}`));
                }
            });

            arjun.on('error', (error) => {
                reject(new Error(`Failed to start arjun: ${error.message}`));
            });
        });
    },
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("arjun MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/cero/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const pty = require('node-pty');

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: cero-mcp <cero binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "cero",
    version: "1.0.0",
});

server.tool(
    "do-cero",
    "Execute Cero, a high-performance certificate-based subdomain enumeration tool. It connects to specified targets over TLS, extracts domain names from certificates (e.g., SAN fields), and outputs discovered hostnames. Useful for reconnaissance and OSINT tasks.",
    {
        target: z.string().describe("The target host or IP address to scan. Can be a single hostname, IPv4/IPv6 address, or a CIDR range (e.g., 192.168.0.0/24)."),
        concurrency: z.number().optional().describe("Maximum number of concurrent TLS connections to use during scanning. Higher values increase speed but consume more system resources."),
        ports: z.array(z.string()).optional().describe("List of TLS ports to scan for certificate information. If omitted, the default port 443 is used. Accepts multiple ports (e.g., ['443', '8443'])."),
        timeOut: z.number().optional().describe("Maximum time (in seconds) to wait for a TLS handshake with a target. Used to prevent long delays on unresponsive hosts. Default is 4 seconds.")
    },
    async ({ target, concurrency, ports, timeOut }) => {


        const ceroArgs = [target];

        if (concurrency) {
            ceroArgs.push("-c", concurrency.toString())
        }

        if (ports && ports.length > 0) {
            ceroArgs.push("-p", ports.join(","));
        }

        if (timeOut) {
            ceroArgs.push("-t", timeOut.toString())
        }


        let output = '';


        const cero = pty.spawn(args[0], ceroArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        cero.on('data', function (data: string) {
            output += data.toString();
            console.log(data.toString())
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            cero.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`cero exited with code ${code}`));
                }
            });
            cero.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start cero: ${error.cause}`));
                }
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}


// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("cero MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/http-headers-security-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import axios from 'axios';
import removeHeadersData from "./owasp_headers_remove.json";
import addHeadersData from "./owasp_headers_add.json";

// Create server instance
const server = new McpServer({
    name: "http-headers-security",
    version: "1.0.0",
});

async function fetchHttpHeaders(target: string): Promise<string[]> {
    try {
        const response = await axios.get(target, {
            timeout: 100000,
            validateStatus: () => true // Accept all status codes
        });

        return Object.entries(response.headers).map(([key, value]) => `${key}: ${value}`);
    } catch (error: unknown) {
        if (error instanceof Error) {
            throw new Error(`Failed to fetch headers: ${error.message}`);
        }
        throw new Error('Failed to fetch headers: Unknown error occurred');
    }
}

async function findMatchingRemoveHeaders(headers: string[]): Promise<string[]> {
    const removeHeaders = removeHeadersData.headers;

    return headers.filter(header => {
        const headerName = header.split(':')[0].trim().toLowerCase();
        return removeHeaders.some(h => h.toLowerCase() === headerName);
    });
}

async function findMatchingAddedHeaders(headers: string[]): Promise<string[]> {
    const addHeaders = addHeadersData.headers;
    const existingHeaderNames = headers.map(header => header.split(':')[0].trim().toLowerCase());

    return addHeaders
        .filter(header => !existingHeaderNames.includes(header.name.toLowerCase()))
        .map(header => `${header.name}: ${header.value}`);
}

server.tool(
    "analyze-http-header",
    "Perform security analysis of HTTP response headers for a web application. This tool examines HTTP headers against OWASP security best practices, identifying both potentially dangerous headers that should be removed and recommended security headers that are missing. Results include specific recommendations for improving security posture.",
    {
        target: z.string().describe("Target URL to analyze (e.g., https://example.com). The tool will make a request to this URL and evaluate its HTTP response headers for security issues."),
    },
    async ({ target }) => {
        return new Promise((resolve, reject) => {
            fetchHttpHeaders(target)
                .then(async headers => {
                    const removeHeaders = await findMatchingRemoveHeaders(headers);
                    const addedHeaders = await findMatchingAddedHeaders(headers);
                    const result = { 
                        removeHeaders: removeHeaders.length > 0 ? removeHeaders : ["No headers to remove"],
                        addedHeaders: addedHeaders.length > 0 ? addedHeaders : ["No headers to add"]
                    };
                    resolve({
                        content: [{
                            type: "text",
                            text: JSON.stringify(result, null, 2)
                        }]
                    });
                })
                .catch(error => {
                    reject(error);
                });
        });
    }
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("http-headers-security MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/nuclei-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const pty = require('node-pty');

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: nuclei-mcp <nuclei binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "nuclei",
    version: "1.0.0",
});

server.tool(
    "do-nuclei",
    "Execute Nuclei, an advanced vulnerability scanner that uses YAML-based templates to detect security vulnerabilities, misconfigurations, and exposures in web applications and infrastructure. Nuclei offers fast scanning with a vast template library covering various security checks.",
    {
        url: z.string().url().describe("Target URL to run nuclei"),
        //nuclei_args: z.array(z.string()).describe(),
        tags: z.array(z.string()).optional().describe("Tags to run nuclei for multiple choise use ,")
    },
    async ({ url, tags }) => {


        const nucleiArgs = ["-u", url, "-silent"];

        if (tags && tags.length > 0) {
            nucleiArgs.push("-tags", tags.join(","));
        }


        let output = '';


        const nuclei = pty.spawn(args[0], nucleiArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        nuclei.on('data', function (data: string) {
            output += data.toString();
            console.log(data.toString())
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            nuclei.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`nuclei exited with code ${code}`));
                }
            });
            nuclei.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start nuclei: ${error.cause}`));
                }
            });
        });
    },
);

server.tool(
    "get-nuclei-tags",
    "Get Nuclei Tags",
    {},
    async () => {
        return new Promise((resolve, reject) => {
            fetch('https://raw.githubusercontent.com/projectdiscovery/nuclei-templates/refs/heads/main/TEMPLATES-STATS.json')
                .then(response => response.json())
                .then((data: { tags: { name: string }[] }) => {
                    const tagNames = data.tags.map(tag => tag.name);
                    resolve({
                        content: [{
                            type: "text",
                            text: JSON.stringify(tagNames)
                        }]
                    });
                })
                .catch(error => {
                    reject(new Error(`Failed to fetch nuclei tags: ${error.message}`));
                });
        });
    }
)


function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}


// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("nuclei MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/alterx-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: alterx-mcp <alterx binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "alterx",
    version: "1.0.0",
});

server.tool(
    "do-alterx",
    "Execute Alterx, a tool that generates domain wordlists using pattern-based permutations for subdomain discovery and DNS enumeration",
    {
        domain: z.string().describe("Target domain or subdomains to use as a base for creating permutations (accepts stdin input, comma-separated values, or file path)"),
        pattern: z.string().describe(`Pattern template for generating wordlist variations. Multiple patterns can be specified using comma-separation.
    
            Available pattern types:
            
            - Dash-based patterns (e.g., api-dev.example.com):
              "{{word}}-{{sub}}.{{suffix}}"  // Produces: dev-api.example.com
              "{{sub}}-{{word}}.{{suffix}}"  // Produces: api-dev.example.com
              
            - Dot-based patterns (e.g., dev.api.example.com):
              "{{word}}.{{sub}}.{{suffix}}"  // Produces: word.api.example.com
              "{{sub}}.{{word}}.{{suffix}}"  // Produces: api.word.example.com
              
            - Iteration-based patterns:
              "{{sub}}{{number}}.{{suffix}}"  // Produces: api1.example.com, api2.example.com
              
            - Replacement patterns:
              "{{word}}.{{suffix}}"  // Replaces current subdomain completely
              
            - No separator patterns:
              "{{sub}}{{word}}.{{suffix}}"  // Produces: apidev.example.com
              
            - Region prefix patterns:
              "{{region}}.{{sub}}.{{suffix}}"  // Produces: us-east.api.example.com
              
            - Combination patterns:
              "{{word}}{{number}}.{{suffix}}"  // Combines words and numbers
            `),
        outputFilePath: z.string().nullable().describe("Path where the generated wordlist should be saved (optional)")
    },
    async ({ domain,pattern,outputFilePath  }) => {
        let alterx;

        const alterxArgs = [];


        alterxArgs.push("-l" ,domain);
        alterxArgs.push('-p', pattern);

        

        if (outputFilePath != null) {
            alterxArgs.push("-o", outputFilePath)
        }

        alterx = spawn(args[0], alterxArgs);


        let output = '';

        // Handle stdout
        alterx.stdout.on('data', (data: Buffer) => {
            output += data.toString();
        });

        // Handle stderr
        alterx.stderr.on('data', (data) => {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            alterx.on('close', (code) => {
                if (code === 0) {
                    resolve({
                        content: [{
                            type: "text",
                            text: output + "\n alterx completed successfully"
                        }]
                    });
                } else {
                    reject(new Error(`alterx exited with code ${code}`));
                }
            });

            alterx.on('error', (error) => {
                reject(new Error(`Failed to start alterx: ${error.message}`));
            });
        });
    },
);

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("alterx MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/smuggler-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { spawn } from 'child_process';

const args = process.argv.slice(2);
if (args.length !== 2) {
    console.error("Usage: smuggler-mcp [python path] [smuggler.py path]");
    process.exit(1);
}

const server = new McpServer({
    name: "smuggler",
    version: "1.0.0",
});

server.tool(
    "do-smuggler",
    "Run Smuggler to detect HTTP Request Smuggling vulnerabilities",
    {
        url: z.string().url().describe("Target URL to detect HTTP Request Smuggling"),
        smuggler_args: z.array(z.string()).optional().describe(`Additional smuggler arguments
        -m, --method METHOD  Specify the HTTP method to use (default: POST)
        -v, --vhost VHOST    Specify a virtual host to use
        -l, --len            Enable Content-Length header in all requests
        -c, --configfile FILE
                             Specify a configuration file to load payloads from
        -x                   Exit on the first finding
        -t, --timeout TIMEOUT
                             Socket timeout value (default: 5)
        -verify VERIFY       Verify findings with more requests; never, quick or thorough (default: quick)`)
    },
    async ({ url, smuggler_args = [] }) => {
        const baseArgs = [args[1],"-u", url];
        const allArgs = [...baseArgs, ...smuggler_args];
        let output = '';

        const smuggler = spawn(args[0],allArgs);

        smuggler.stdout.on('data', (data) => {
            output += data.toString();
        });

        smuggler.stderr.on('data', (data) => {
            output += data.toString();
        });

        return new Promise((resolve, reject) => {
            smuggler.on('close', (code) => {
                if (code === 0) {
                    output = removeAnsiCodes(output);
                    const vulnResults = parseResults(output);
                    
                    resolve({
                        content: [{
                            type: "text",
                            text: output
                        }],
                        metadata: {
                            findings: vulnResults
                        }
                    });
                } else {
                    reject(new Error(`Smuggler exited with code ${code}`));
                }
            });
            
            smuggler.on('error', (error) => {
                reject(new Error(`Failed to start Smuggler: ${error.message}`));
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*[mGK]/g, '');
}

interface VulnEntry {
    mutation: string;
    severity: string;
}

function parseResults(output: string): any {
    const vulnerabilities: {
        cl_te: VulnEntry[];
        te_cl: VulnEntry[];
    } = {
        cl_te: [],
        te_cl: []
    };

    const clteRegex = /\[(\+|\!)\] Potential (CL\.TE) Vulnerability Found \((\w+)\)/gi;
    const teclRegex = /\[(\+|\!)\] Potential (TE\.CL) Vulnerability Found \((\w+)\)/gi;

    let match;
    while ((match = clteRegex.exec(output)) !== null) {
        vulnerabilities.cl_te.push({
            mutation: match[3],
            severity: match[1] === '+' ? 'high' : 'medium'
        });
    }

    while ((match = teclRegex.exec(output)) !== null) {
        vulnerabilities.te_cl.push({
            mutation: match[3],
            severity: match[1] === '+' ? 'high' : 'medium'
        });
    }

    return vulnerabilities;
}

async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("Smuggler MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
}); 
```

--------------------------------------------------------------------------------
/httpx-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const pty = require('node-pty');
const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: httpx-mcp <httpx binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "httpx",
    version: "1.0.0",
});

server.tool(
    "httpx",
    "Scans the given target domains and detects active HTTP/HTTPS services on ports like 80 and 443.",
    {
        target: z.array(z.string()).describe("A list of domain names (e.g., example.com) to scan for HTTP and HTTPS services."),
        ports: z.array(z.number()).optional().describe(""),
        probes: z.array(z.string()).optional().describe(`Available probe options:
            status-code      Display response status-code
            content-length   Display response content-length
            content-type     Display response content-type
            location         Display response redirect location
            favicon          Display mmh3 hash for '/favicon.ico' file
            hash             Display response body hash (supported: md5,mmh3,simhash,sha1,sha256,sha512)
            jarm             Display jarm fingerprint hash
            response-time    Display response time
            line-count       Display response body line count
            word-count       Display response body word count
            title            Display page title
            body-preview     Display first N characters of response body (default 100)
            web-server       Display server name
            tech-detect      Display technology in use based on wappalyzer dataset
            method           Display http request method
            websocket        Display server using websocket
            ip               Display host ip
            cname            Display host cname
            extract-fqdn     Get domain and subdomains from response body and header
            asn              Display host asn information
            cdn              Display cdn/waf in use (default true)
            probe            Display probe status`)
    },
    async ({ target, ports, probes }) => {


        const httpxArgs = ["-u", target.join(","), "-silent"];

        if (ports && ports.length > 0) {
            httpxArgs.push("-p", ports.join(","));
        }

        if (probes && probes.length > 0) {
            for (const probe of probes) {
                httpxArgs.push(`-${probe}`);
            }
        }

        let output = '';


        const httpx = pty.spawn(args[0], httpxArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        httpx.on('data', function (data: string) {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            httpx.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`httpx exited with code ${code}`));
                }
            });
            httpx.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start httpx: ${error.cause}`));
                }
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("httpx MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

--------------------------------------------------------------------------------
/katana-mcp/src/index.ts:
--------------------------------------------------------------------------------

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const pty = require('node-pty');
const args = process.argv.slice(2);
if (args.length === 0) {
    console.error("Usage: katana-mcp <katana binary>");
    process.exit(1);
}

// Create server instance
const server = new McpServer({
    name: "katana",
    version: "1.0.0",
});

server.tool(
    "do-katana",
    "Performs fast and configurable web crawling on the given target URLs, identifying endpoints, parameters, and JS-based links.",
    {
        target: z.array(z.string()).describe("List of target URLs (e.g., https://example.com) to scan for endpoints and JavaScript-based links."),
        exclude: z.array(z.string()).optional().describe("List of URLs or regex patterns to exclude from crawling."),
        depth: z.number().optional().describe("Maximum crawl depth (e.g., 3 for three levels deep)."),
        js_crawl: z.boolean().optional().describe("Enable crawling and endpoint extraction from JavaScript files."),
        jsluice: z.boolean().optional().describe("Enable JSluice parsing for deeper JavaScript-based link analysis (memory intensive)."),
        headers: z.array(z.string()).optional().describe("List of custom headers or cookies to include in requests (format: Header:Value)."),
        strategy: z.enum(["depth-first", "breadth-first"]).optional().describe("Crawling strategy to use: 'depth-first' or 'breadth-first' (default is depth-first)."),
        headless: z.boolean().optional().describe("Enable headless browser-based hybrid crawling (experimental)."),
        system_chrome: z.boolean().optional().describe("Use the locally installed Chrome browser instead of the built-in one."),
        show_brwoser: z.boolean().optional().describe("Show the browser window even in headless mode (for debugging/visual inspection)."),
    },
    async ({ target, exclude, depth, js_crawl, jsluice, headers, strategy, headless, system_chrome, show_brwoser }) => {
        
        const katanaArgs = ["-u", target.join(","), "-silent"];

        if (exclude && exclude.length > 0) {
            katanaArgs.push("-exclude", exclude.join(","));
        }
        if (depth !== undefined) {
            katanaArgs.push("-d", depth.toString());
        }
        if (js_crawl) {
            katanaArgs.push("-jc");
        }
        if (jsluice) {
            katanaArgs.push("-jsl");
        }
        if (headers && headers.length > 0) {
            headers.forEach(header => katanaArgs.push("-H", header));
        }
        if (strategy) {
            katanaArgs.push("-strategy", strategy);
        }
        if (headless) {
            katanaArgs.push("-headless");
        }
        if (system_chrome) {
            katanaArgs.push("-system-chrome");
        }
        if (show_brwoser) {
            katanaArgs.push("-show-browser");
        }
        let output = "";

        const katana = pty.spawn(args[0], katanaArgs, {
            name: 'xterm-color',
            cols: 80,
            rows: 30,
            cwd: process.cwd(),
            env: process.env
        });

        katana.on('data', function (data: string) {
            output += data.toString();
        });

        // Handle process completion
        return new Promise((resolve, reject) => {
            katana.on('close', function (code: number) {
                if (code === 0 || typeof code === "undefined") {
                    output = removeAnsiCodes(output)
                    const resolveData: any = {
                        content: [{
                            type: "text",
                            text: output
                        }]
                    };
                    resolve(resolveData);
                } else {
                    reject(new Error(`katana exited with code ${code}`));
                }
            });
            katana.on('error', function (error: Error) {
                if (typeof error.cause !== "undefined") {
                    reject(new Error(`Error to start katana: ${error.cause}`));
                }
            });
        });
    },
);

function removeAnsiCodes(input: string): string {
    return input.replace(/\x1B\[[0-9;]*m/g, '');
}

// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("katana MCP Server running on stdio");
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});
```

