@clawhub-krishnakumarmahadevan-cmd-f85de8e757
Professional OpenShift Container Platform security configuration generator that creates hardened deployment manifests and security policies.
---
name: Red Hat OpenShift Security Hardening Tool
description: Professional OpenShift Container Platform security configuration generator that creates hardened deployment manifests and security policies.
---
# Overview
The Red Hat OpenShift Security Hardening Tool is a professional-grade API designed to generate security-hardened configuration files for OpenShift Container Platform deployments. Built for DevSecOps teams and platform engineers, this tool automates the creation of security baselines that align with industry best practices and compliance frameworks.
The tool enables organizations to rapidly deploy secure OpenShift clusters by generating pre-configured security policies, network policies, RBAC configurations, and pod security standards. Rather than manually crafting security controls, users specify their hardening requirements and receive production-ready configuration files that enforce security controls across their containerized infrastructure.
Ideal users include DevSecOps engineers, Kubernetes platform administrators, security architects, and organizations undergoing compliance audits (SOC 2, PCI-DSS, HIPAA) who need to demonstrate and maintain security posture across OpenShift deployments.
## Usage
### Sample Request
```json
{
"sessionId": "sess_8f3c4a2b9e1d7f5k",
"userId": 12345,
"timestamp": "2024-01-15T10:30:00Z",
"hardeningOptions": {
"networkPolicy": ["deny-all-ingress", "allow-dns", "allow-api-server"],
"rbac": ["least-privilege", "service-account-restriction"],
"podSecurity": ["restricted", "audit-logging"],
"imageSecurity": ["image-scanning", "registry-whitelist"],
"encryption": ["etcd-encryption", "tls-everywhere"]
}
}
```
### Sample Response
```json
{
"status": "success",
"sessionId": "sess_8f3c4a2b9e1d7f5k",
"timestamp": "2024-01-15T10:30:05Z",
"hardeningConfig": {
"networkPolicies": [
{
"apiVersion": "networking.k8s.io/v1",
"kind": "NetworkPolicy",
"metadata": {
"name": "default-deny-ingress",
"namespace": "default"
},
"spec": {
"podSelector": {},
"policyTypes": ["Ingress"]
}
}
],
"rbacConfigurations": [
{
"apiVersion": "rbac.authorization.k8s.io/v1",
"kind": "ClusterRole",
"metadata": {
"name": "pod-reader"
},
"rules": [
{
"apiGroups": [""],
"resources": ["pods"],
"verbs": ["get", "list"]
}
]
}
],
"podSecurityStandards": {
"enforce": "restricted",
"audit": "restricted",
"warn": "restricted"
},
"securityPolicies": {
"imagePullPolicy": "Always",
"allowPrivilegedEscalation": false,
"runAsNonRoot": true,
"readOnlyRootFilesystem": true
}
},
"configFiles": {
"count": 12,
"formats": ["yaml", "json"],
"downloadUrl": "https://api.mkkpro.com/hardening/openshift/download/sess_8f3c4a2b9e1d7f5k"
},
"complianceMapping": {
"frameworks": ["CIS Kubernetes Benchmark", "NIST Cybersecurity Framework", "PCI-DSS"],
"coveragePercentage": 94
}
}
```
## Endpoints
### GET /
Health check endpoint to verify API availability.
**Method:** `GET`
**Path:** `/`
**Description:** Returns service health status and basic API information.
**Parameters:** None
**Response Schema:**
```
Status: 200 OK
Content-Type: application/json
Body: {} (empty object or service status metadata)
```
---
### POST /api/hardening/generate
Generate OpenShift security hardening configuration files based on specified security requirements.
**Method:** `POST`
**Path:** `/api/hardening/generate`
**Description:** Accepts hardening options and generates complete, production-ready OpenShift security configuration files including network policies, RBAC rules, pod security standards, and encryption settings.
**Request Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `sessionId` | string | Yes | Unique session identifier for tracking and audit purposes |
| `userId` | integer | No | Optional user identifier for multi-tenant tracking |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp of the request |
| `hardeningOptions` | object | Yes | Dictionary mapping hardening categories to arrays of specific options (e.g., `{"networkPolicy": ["deny-all-ingress"], "rbac": ["least-privilege"]}`) |
**Response Schema:**
```
Status: 200 OK
Content-Type: application/json
Body: {
"status": "success",
"sessionId": "string",
"timestamp": "string",
"hardeningConfig": {
"networkPolicies": [...],
"rbacConfigurations": [...],
"podSecurityStandards": {...},
"securityPolicies": {...}
},
"configFiles": {
"count": integer,
"formats": ["yaml", "json"],
"downloadUrl": "string"
},
"complianceMapping": {
"frameworks": [...],
"coveragePercentage": integer
}
}
```
**Error Response (422):**
```
Status: 422 Unprocessable Entity
Content-Type: application/json
Body: {
"detail": [
{
"loc": ["body", "hardeningOptions"],
"msg": "field required",
"type": "value_error.missing"
}
]
}
```
---
### GET /api/hardening/options
Retrieve all available hardening options and categories supported by the tool.
**Method:** `GET`
**Path:** `/api/hardening/options`
**Description:** Returns a comprehensive list of all available hardening options organized by category, including descriptions and compatibility information for different OpenShift versions.
**Parameters:** None
**Response Schema:**
```
Status: 200 OK
Content-Type: application/json
Body: {
"categories": {
"networkPolicy": {
"options": [
{"id": "deny-all-ingress", "description": "...", "versions": ["4.10+"]},
{"id": "allow-dns", "description": "...", "versions": ["4.10+"]}
]
},
"rbac": {
"options": [
{"id": "least-privilege", "description": "...", "versions": ["4.10+"]},
{"id": "service-account-restriction", "description": "...", "versions": ["4.10+"]}
]
},
"podSecurity": {...},
"imageSecurity": {...},
"encryption": {...}
},
"metadata": {
"totalOptions": integer,
"lastUpdated": "string"
}
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/openshift
- **API Documentation:** https://api.mkkpro.com:8144/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Red Hat OpenShift Security Hardening Tool",
"description": "Professional OpenShift Container Platform Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate OpenShift security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates hardened security configurations for Check Point systems based on specified hardening options.
---
name: Check Point Hardening Tool
description: Generates hardened security configurations for Check Point systems based on specified hardening options.
---
# Overview
The Check Point Hardening Tool is a security-focused API that automates the generation of hardened configurations for Check Point security appliances and gateways. This tool enables security teams to quickly apply industry best practices and compliance-driven hardening templates to their Check Point infrastructure, reducing manual configuration time and minimizing security misconfigurations.
The tool accepts a set of hardening parameters—such as encryption standards, access control policies, logging levels, and compliance frameworks—and generates optimized configuration outputs tailored to your security posture requirements. It is ideal for organizations deploying Check Point solutions, security architects performing baseline hardening, compliance teams implementing regulatory requirements (PCI-DSS, HIPAA, SOC 2), and DevSecOps teams automating infrastructure security.
By leveraging this API, teams can maintain consistent hardening standards across distributed Check Point deployments, reduce configuration drift, and ensure alignment with organizational security policies and external compliance mandates.
## Usage
**Sample Request:**
```json
{
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"userId": 12345,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"encryption": ["AES-256", "TLS1.3"],
"accessControl": ["mfa_enabled", "ip_whitelist"],
"logging": ["syslog", "audit_trail", "threat_prevention"],
"complianceFramework": ["pci-dss", "soc2"]
}
}
```
**Sample Response:**
```json
{
"configurationId": "cfg_xyz789abc",
"status": "success",
"generatedAt": "2024-01-15T14:30:05Z",
"hardeningProfile": {
"encryption": {
"algorithm": "AES-256",
"tlsVersion": "TLS1.3",
"cipherSuites": ["TLS_AES_256_GCM_SHA384"]
},
"accessControl": {
"mfaRequired": true,
"ipWhitelistEnabled": true,
"defaultDenyPolicy": true
},
"logging": {
"syslogEnabled": true,
"auditTrailEnabled": true,
"threatPreventionLogging": true,
"logRetention": "90 days"
},
"compliance": {
"frameworks": ["PCI-DSS v3.2.1", "SOC 2 Type II"],
"validationStatus": "compliant"
}
},
"appliedRules": 47,
"estimatedDeploymentTime": "15 minutes"
}
```
## Endpoints
### POST /api/hardening/generate
**Description:** Generates a hardened Check Point configuration based on the provided hardening options, session context, and compliance requirements.
**Method:** `POST`
**Path:** `/api/hardening/generate`
**Request Body:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | Object (map of string → array of strings) | Yes | A flexible key-value map where keys represent hardening categories (e.g., "encryption", "accessControl", "logging", "complianceFramework") and values are arrays of specific hardening options or standards to apply. |
| `sessionId` | String | Yes | A unique identifier for the current API session, used for request tracking and audit logging. |
| `userId` | Integer | No | The numeric identifier of the user initiating the hardening configuration. Used for audit trails and access control validation. |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp (e.g., "2024-01-15T14:30:00Z") indicating when the hardening request was generated. |
**Response (200 - Success):**
Returns a JSON object containing:
- `configurationId` (string): Unique identifier for the generated hardening configuration
- `status` (string): Operation status ("success", "partial", "failed")
- `generatedAt` (string): ISO 8601 timestamp of configuration generation
- `hardeningProfile` (object): Detailed hardening settings organized by category
- `appliedRules` (integer): Number of hardening rules applied
- `estimatedDeploymentTime` (string): Estimated time to deploy configuration
**Response (422 - Validation Error):**
Returns validation error details including:
- `detail` (array): Array of validation errors with `loc` (error location), `msg` (error message), and `type` (error type)
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/checkpoint
- **API Docs:** https://api.mkkpro.com:8143/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Check Point Hardening Tool",
"version": "1.0.0"
},
"paths": {
"/api/hardening/generate": {
"post": {
"summary": "Generate",
"operationId": "generate_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"type": "integer",
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates hardened Cisco ASA firewall configurations based on security best practices and specified hardening options.
---
name: Cisco ASA Hardening Tool
description: Generates hardened Cisco ASA firewall configurations based on security best practices and specified hardening options.
---
# Overview
The Cisco ASA Hardening Tool is a specialized security configuration generator designed for network administrators and security engineers working with Cisco Adaptive Security Appliances (ASA). This tool automates the process of creating hardened firewall configurations by applying industry-standard security best practices and custom hardening parameters.
The tool excels at reducing manual configuration effort, ensuring consistent security posture across deployments, and helping organizations meet compliance requirements. It accepts a set of hardening options and session metadata, then generates optimized ASA configurations tailored to your security requirements.
Ideal users include enterprise network teams, managed service providers (MSPs), security consultants, and DevSecOps professionals who manage Cisco ASA infrastructure at scale and need repeatable, standardized hardening procedures.
## Usage
**Example Request:**
```json
{
"sessionId": "sess_abc123def456",
"userId": 12345,
"timestamp": "2024-01-15T10:30:00Z",
"hardeningOptions": {
"accessControl": ["restrictAdminAccess", "enableMFA"],
"encryption": ["enableSSLTLS", "disableWeakCiphers"],
"logging": ["enableDetailedLogging", "centralizeEventLogs"],
"inspection": ["enableDPIInspection", "enableThreatDetection"]
}
}
```
**Example Response:**
```json
{
"status": "success",
"configurationId": "cfg_xyz789",
"generatedConfig": {
"accessControl": {
"adminAccess": "restricted_to_trusted_networks",
"mfa": "enabled",
"commands": [
"aaa authentication enable console LOCAL",
"aaa authentication telnet console LOCAL"
]
},
"encryption": {
"sslTls": "enabled",
"tlsVersion": "1.2_and_higher",
"commands": [
"ssl encryption HIGH",
"no ssl server-version tlsv1"
]
},
"logging": {
"detailedLogging": "enabled",
"syslogServer": "configured",
"commands": [
"logging enable",
"logging host inside 192.168.1.100"
]
},
"inspection": {
"dpiInspection": "enabled",
"threatDetection": "enabled",
"commands": [
"class-map inspection_default",
"inspect dns maximum-length 512"
]
}
},
"appliedOptions": 4,
"estimatedDeploymentTime": "15 minutes",
"timestamp": "2024-01-15T10:30:45Z"
}
```
## Endpoints
### POST /api/asa/generate
**Description:** Generates a hardened Cisco ASA configuration based on the provided hardening options and session parameters.
**Method:** `POST`
**Path:** `/api/asa/generate`
**Request Body:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | object (map of string to array of strings) | Yes | A dictionary where keys represent hardening categories (e.g., "accessControl", "encryption") and values are arrays of specific hardening techniques to apply |
| `sessionId` | string | Yes | Unique identifier for the current session, used for tracking and audit purposes |
| `userId` | integer or null | No | Numeric user identifier associated with the configuration request; optional for anonymous usage |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp indicating when the request was submitted |
**Response (200 - Success):**
Returns a JSON object containing the generated hardened ASA configuration with the following typical structure:
- `status`: string indicating success or failure
- `configurationId`: unique identifier for the generated configuration
- `generatedConfig`: object containing organized hardening configurations by category, including both settings and CLI commands
- `appliedOptions`: integer count of hardening options successfully applied
- `estimatedDeploymentTime`: string estimate for configuration deployment
- `timestamp`: ISO 8601 timestamp of response generation
**Response (422 - Validation Error):**
Returns validation error details if required parameters are missing or malformed:
```json
{
"detail": [
{
"loc": ["body", "hardeningOptions"],
"msg": "field required",
"type": "value_error.missing"
}
]
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- Kong Route: https://api.mkkpro.com/hardening/cisco-asa
- API Docs: https://api.mkkpro.com:8142/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco ASA Hardening Tool",
"version": "1.0.0"
},
"paths": {
"/api/asa/generate": {
"post": {
"summary": "Generate",
"operationId": "generate_api_asa_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/ASARequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
}
},
"components": {
"schemas": {
"ASARequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "ASARequest"
},
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional security configuration generator for Cisco Firepower Threat Defense based on CIS Benchmark v1.0.0.
---
name: Cisco Firepower Threat Defense Security Hardening Tool
description: Professional security configuration generator for Cisco Firepower Threat Defense based on CIS Benchmark v1.0.0.
---
# Overview
The Cisco Firepower Threat Defense Security Hardening Tool is a professional-grade API that generates hardened security configurations for Cisco Firepower devices in compliance with CIS Benchmark standards. This tool automates the creation of security policies and configuration files, ensuring your Firepower infrastructure meets industry best practices and regulatory compliance requirements.
Security teams and network administrators use this tool to rapidly deploy consistent, standards-aligned configurations across their Firepower Threat Defense deployments. Rather than manually crafting configurations, users specify their desired hardening options and receive production-ready configuration files that enforce security controls aligned with CIS Benchmark v1.0.0.
The tool is ideal for organizations implementing defense-in-depth strategies, preparing for security audits, or standardizing Firepower configurations across multiple deployments. It significantly reduces configuration drift and human error while maintaining audit trails through session and user tracking.
## Usage
### Example Request
Generate a hardened Firepower configuration with access control and encryption options enabled:
```json
{
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"userId": 12345,
"timestamp": "2024-01-15T10:30:00Z",
"hardeningOptions": {
"accessControl": ["enable_default_deny", "disable_ping"],
"encryption": ["tls_1_2_minimum", "aes256_cipher"],
"logging": ["enable_threat_logging", "enable_connection_logging"],
"updates": ["auto_update_enabled", "check_signatures_daily"]
}
}
```
### Example Response
```json
{
"status": "success",
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"configurationId": "cfg_9x8y7z6w5v4u3t2s",
"timestamp": "2024-01-15T10:30:15Z",
"hardening": {
"accessControl": {
"enable_default_deny": {
"status": "applied",
"description": "Default deny-all policy enabled"
},
"disable_ping": {
"status": "applied",
"description": "ICMP ping responses disabled"
}
},
"encryption": {
"tls_1_2_minimum": {
"status": "applied",
"description": "TLS 1.2 set as minimum protocol version"
},
"aes256_cipher": {
"status": "applied",
"description": "AES-256 encryption enabled"
}
},
"logging": {
"enable_threat_logging": {
"status": "applied",
"description": "Threat detection logging enabled"
},
"enable_connection_logging": {
"status": "applied",
"description": "Connection logging enabled"
}
},
"updates": {
"auto_update_enabled": {
"status": "applied",
"description": "Automatic updates enabled"
},
"check_signatures_daily": {
"status": "applied",
"description": "Daily signature checks enabled"
}
}
},
"configurationOutput": {
"cli_commands": ["access-list default_deny deny ip any any", ...],
"policy_xml": "<configuration>...</configuration>"
},
"appliedControls": 8,
"complianceLevel": "CIS Benchmark v1.0.0"
}
```
## Endpoints
### GET /
**Health Check Endpoint**
Returns the service status to verify API availability.
**Parameters:** None
**Response:**
```
200 OK - Service is operational
```
---
### POST /api/hardening/generate
**Generate Hardening Configuration**
Generates Cisco Firepower security hardening configuration files based on specified options aligned with CIS Benchmark standards.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `hardeningOptions` | object | Yes | Dictionary mapping hardening categories to arrays of specific options (e.g., `{"accessControl": ["enable_default_deny"], "encryption": ["tls_1_2_minimum"]}`) |
| `sessionId` | string | Yes | Unique session identifier for request tracking and audit purposes |
| `userId` | integer | No | Numeric user identifier for request attribution and multi-user scenarios |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp of request creation (e.g., `2024-01-15T10:30:00Z`) |
**Request Body Schema:**
- `hardeningOptions` (object, required): Key-value pairs where keys are hardening categories and values are arrays of configuration option strings
- `sessionId` (string, required): Unique identifier for the session
- `userId` (integer or null, optional): User identifier
- `timestamp` (string, required): ISO 8601 timestamp
**Response:**
```
200 OK - Configuration generated successfully with applied controls, compliance level, and CLI commands/policy XML
422 Unprocessable Entity - Validation error in request parameters
```
---
### GET /api/hardening/options
**Get Available Hardening Options**
Retrieves all available Firepower hardening options and categories that can be used in configuration generation requests.
**Parameters:** None
**Response:**
```
200 OK - JSON object containing all available hardening categories and options
```
Response includes:
- Available hardening categories (e.g., accessControl, encryption, logging, updates)
- Specific configuration options within each category
- Descriptions and CIS Benchmark mappings for each option
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/cisco-ftd
- **API Docs:** https://api.mkkpro.com:8141/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco Firepower Threat Defense Security Hardening Tool",
"description": "Professional Security Configuration Generator based on CIS Benchmark v1.0.0",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Cisco Firepower security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available Firepower hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generate CIS-compliant hardened Cisco ASA/FTD firewall configurations with customizable security options to enforce best practices and reduce manual errors.
name: Cisco Firewall Hardening Tool
description: Generate CIS-compliant Cisco ASA/FTD configurations with security best practices.
```
# Overview
The Cisco Firewall Hardening Tool automates the generation of CIS-compliant security configurations for Cisco ASA and FTD (Firewall Threat Defense) devices. This tool eliminates manual hardening workflows by producing production-ready configurations based on industry security standards and best practices.
Organizations managing Cisco firewall infrastructure benefit from rapid, consistent security posture improvements. The tool supports flexible hardening options, enabling security teams to customize configurations to their specific compliance requirements and network architecture. It is ideal for enterprise security teams, managed security service providers (MSSPs), and DevSecOps professionals who need to deploy hardened firewall configurations at scale.
By automating compliance-driven configuration generation, the tool reduces human error, accelerates deployment timelines, and ensures adherence to CIS benchmarks across your firewall estate.
## Usage
**Generate a hardened Cisco ASA configuration:**
```json
{
"sessionId": "sess-12345abcde",
"userId": 42,
"timestamp": "2024-01-15T10:30:00Z",
"hardeningOptions": {
"accessControl": [
"disable-default-telnet",
"enforce-ssh-only"
],
"logging": [
"enable-syslog",
"enable-audit-logging"
],
"encryption": [
"enforce-tls-1.2-minimum",
"disable-weak-ciphers"
]
}
}
```
**Response:**
```json
{
"status": "success",
"configurationId": "cfg-9876xyz",
"deviceType": "Cisco ASA",
"cisCompliance": "CIS Cisco ASA Firewall Benchmark v1.1",
"configuration": {
"accessControl": {
"telnet": "disabled",
"ssh": "enabled",
"protocol": "SSHv2",
"ciphers": "aes256-ctr,aes192-ctr,aes128-ctr"
},
"logging": {
"syslog": "enabled",
"auditLog": "enabled",
"level": "informational"
},
"encryption": {
"tlsMinimum": "1.2",
"weakCiphers": "disabled"
}
},
"appliedRules": 24,
"timestamp": "2024-01-15T10:30:15Z"
}
```
## Endpoints
### GET /
**Summary:** Root endpoint for service health check.
**Parameters:** None
**Response:** Service information and status.
---
### GET /test
**Summary:** Test endpoint for connectivity verification.
**Parameters:** None
**Response:** Simple test acknowledgment.
---
### POST /api/cisco-hardening/generate
**Summary:** Generate a hardened Cisco firewall configuration.
**Method:** `POST`
**Path:** `/api/cisco-hardening/generate`
**Description:** Generates a CIS-compliant configuration for Cisco ASA or FTD devices based on specified hardening options. Returns production-ready configuration snippets and applied security rules.
**Request Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | object | Yes | Key-value mapping where keys are hardening categories and values are arrays of specific hardening rules to apply (e.g., `{"accessControl": ["disable-default-telnet"], "logging": ["enable-syslog"]}`) |
| `sessionId` | string | Yes | Unique session identifier for tracking and audit purposes |
| `userId` | integer \| null | No | Optional user identifier for audit logging and usage attribution |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp indicating request generation time (e.g., `2024-01-15T10:30:00Z`) |
**Response Shape:**
```json
{
"status": "string",
"configurationId": "string",
"deviceType": "string",
"cisCompliance": "string",
"configuration": "object",
"appliedRules": "integer",
"timestamp": "string"
}
```
**Error Responses:**
- `422 Validation Error`: Invalid request parameters or missing required fields. Returns validation error details.
---
### GET /api/cisco-hardening/options
**Summary:** Retrieve available hardening options and categories.
**Method:** `GET`
**Path:** `/api/cisco-hardening/options`
**Description:** Lists all supported hardening option categories and individual rules available for configuration generation. Use this endpoint to discover valid values for the `hardeningOptions` parameter.
**Parameters:** None
**Response Shape:**
```json
{
"categories": [
{
"name": "string",
"description": "string",
"rules": [
{
"id": "string",
"label": "string",
"description": "string"
}
]
}
]
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/cisco-firewall
- **API Docs:** https://api.mkkpro.com:8140/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco Firewall Hardening Tool",
"description": "Generate CIS-compliant Cisco ASA/FTD configurations",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/test": {
"get": {
"summary": "Test",
"operationId": "test_test_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/cisco-hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"operationId": "generate_hardening_config_api_cisco_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/cisco-hardening/options": {
"get": {
"summary": "Get Options",
"operationId": "get_options_api_cisco_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional Cisco Router & Switch Security Configuration Generator
---
name: Cisco IOS XE Security Hardening Tool
description: Professional Cisco Router & Switch Security Configuration Generator
---
# Overview
The Cisco IOS XE Security Hardening Tool is a professional-grade API service designed to automatically generate security-hardened configuration files for Cisco routers and switches running IOS XE. Built for network security engineers, compliance officers, and infrastructure teams, this tool eliminates manual configuration errors and accelerates the deployment of security best practices across enterprise Cisco environments.
This tool enables security-focused organizations to rapidly generate compliant, hardened configurations that align with industry standards and internal security policies. By automating the configuration generation process, teams reduce human error, ensure consistency across network devices, and maintain audit-ready documentation of security implementations.
Ideal users include network security engineers, infrastructure architects, compliance teams managing large Cisco deployments, managed service providers (MSPs), and organizations undergoing security certifications or regulatory audits requiring documented hardening standards.
# Usage
## Sample Request
Generate a hardened Cisco IOS XE configuration with SSH, NTP security, and access control options enabled:
```json
{
"sessionId": "sess_6f8c4d92e1a3b5c7",
"userId": 12847,
"timestamp": "2025-01-15T14:23:45Z",
"hardeningOptions": {
"authentication": ["ssh", "aaa"],
"encryption": ["ipsec", "tls"],
"logging": ["syslog", "netflow"],
"access_control": ["acl", "rbac"]
}
}
```
## Sample Response
```json
{
"status": "success",
"sessionId": "sess_6f8c4d92e1a3b5c7",
"configurationId": "cfg_a7f2e9d1c3b6",
"timestamp": "2025-01-15T14:23:46Z",
"hardening_applied": [
"SSH_ENABLE",
"AAA_CONFIGURATION",
"IPSEC_TUNNEL_SETUP",
"TLS_CERTIFICATE_INSTALL",
"SYSLOG_SERVER_CONFIG",
"NETFLOW_ENABLE",
"ACL_DEPLOYMENT",
"RBAC_ROLES"
],
"configuration_snippet": "ip ssh version 2\nip ssh authentication retries 2\nip ssh time-out 60\naaa new-model\n...",
"estimated_lines": 247,
"supported_platforms": ["Catalyst 9300", "Catalyst 9400", "ISR 4000", "ASR 1000"],
"warnings": [],
"next_steps": "Review configuration, test in lab environment, apply to device using SCP or Ansible"
}
```
# Endpoints
## GET /
**Health Check Endpoint**
Returns service status and availability.
**Method:** GET
**Path:** `/`
**Parameters:** None
**Response:**
- HTTP 200: Service is operational
- Content-Type: `application/json`
- Response body: Health status object
---
## POST /api/hardening/generate
**Generate Hardening Config**
Generates Cisco IOS XE security hardening configuration files based on selected hardening options.
**Method:** POST
**Path:** `/api/hardening/generate`
**Request Body (JSON):**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `sessionId` | string | Yes | Unique session identifier for request tracking |
| `userId` | integer or null | No | User identifier for audit logging and billing attribution |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp of request generation |
| `hardeningOptions` | object | Yes | Dictionary of hardening categories with array of enabled options (e.g., `{"authentication": ["ssh", "aaa"], "encryption": ["ipsec"]}`) |
**Response (HTTP 200):**
- Content-Type: `application/json`
- Successful generation response with configuration details, applied hardening measures, estimated configuration line count, supported platforms, and warnings
**Response (HTTP 422):**
- Validation Error - returned when required fields are missing or malformed
- Contains `detail` array with validation error objects (`loc`, `msg`, `type`)
---
## GET /api/hardening/options
**Get Hardening Options**
Retrieves all available hardening options, categories, and supported configurations for Cisco IOS XE devices.
**Method:** GET
**Path:** `/api/hardening/options`
**Parameters:** None
**Response (HTTP 200):**
- Content-Type: `application/json`
- Returns complete catalog of available hardening options organized by category (authentication, encryption, logging, access_control, threat_defense, etc.)
- Each option includes description, platform compatibility, and configuration complexity
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/cisco-iosxe
- **API Docs:** https://api.mkkpro.com:8139/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco IOS XE Security Hardening Tool",
"description": "Professional Cisco Router & Switch Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Cisco IOS XE security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generate security hardening configurations for Cisco IOS XR devices with customizable hardening options.
---
name: Cisco IOS XR Hardening Tool
description: Generate security hardening configurations for Cisco IOS XR devices with customizable hardening options.
---
# Overview
The Cisco IOS XR Hardening Tool is a security-focused API that automates the generation of hardening configurations for Cisco IOS XR networking devices. This tool enables network engineers and security teams to quickly produce baseline security configurations aligned with industry best practices, reducing manual configuration time and minimizing security misconfigurations.
The tool accepts customizable hardening options and generates device-ready configurations that can be directly deployed or reviewed before implementation. With built-in session tracking and timestamp validation, it supports audit trails and integration into automated network security workflows.
Ideal users include network administrators, security operations teams, infrastructure automation engineers, and organizations managing large Cisco IOS XR deployments who need consistent, repeatable security hardening across their network infrastructure.
# Usage
**Sample Request:**
```json
{
"sessionId": "sess_abc123def456",
"userId": 1001,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"enableAAAAuthentication": true,
"disableUnusedServices": true,
"enforceSSHOnly": true,
"enableLogging": true,
"applyAccessLists": true,
"minimumSecurityLevel": "high"
}
}
```
**Sample Response:**
```json
{
"status": "success",
"sessionId": "sess_abc123def456",
"timestamp": "2024-01-15T14:30:05Z",
"config": {
"aaa": "aaa authentication login default group tacacs+ local\naaa authorization exec default group tacacs+ local",
"services": "no service udp-small-servers\nno service tcp-small-servers\nno telnet",
"ssh": "ip ssh version 2\nip ssh rsa keypair-name ssh-key",
"logging": "logging 10.0.0.1 severity 6\nlogging facility local6",
"acl": "access-list 101 permit ip 10.0.0.0 0.0.0.255 any"
},
"appliedOptions": {
"enableAAAAuthentication": true,
"disableUnusedServices": true,
"enforceSSHOnly": true,
"enableLogging": true,
"applyAccessLists": true
}
}
```
# Endpoints
## POST /api/hardening/generate
Generates a security hardening configuration for Cisco IOS XR devices based on provided options.
**Method:** `POST`
**Path:** `/api/hardening/generate`
**Description:** Accepts a hardening request with customizable security options and returns a generated configuration ready for deployment or review.
**Request Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `hardeningOptions` | object | Yes | Object containing specific hardening configurations to apply (e.g., authentication, service restrictions, logging policies). |
| `sessionId` | string | Yes | Unique session identifier for tracking and audit purposes. |
| `userId` | integer | No | ID of the user requesting the hardening configuration for audit logging. |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp indicating when the request was generated. |
**Response Shape:**
```json
{
"status": "string",
"sessionId": "string",
"timestamp": "string",
"config": "object",
"appliedOptions": "object",
"warnings": ["string"]
}
```
**Status Codes:**
- `200 OK`: Configuration generated successfully.
- `422 Unprocessable Entity`: Request validation failed (missing or invalid parameters).
---
## GET /
Returns service status and basic information about the API.
**Method:** `GET`
**Path:** `/`
**Description:** Health check and root endpoint providing API metadata and availability status.
**Response Shape:**
```json
{
"status": "string",
"version": "string",
"service": "string"
}
```
**Status Codes:**
- `200 OK`: Service is operational.
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/cisco-iosxr
- **API Docs:** https://api.mkkpro.com:8138/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco IOS XR Hardening Tool",
"version": "1.0.1"
},
"paths": {
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/": {
"get": {
"summary": "Root",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"type": "integer",
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates security hardening configurations for Cisco NX-OS network devices based on specified options.
---
name: Cisco NX-OS Hardening Tool
description: Generates security hardening configurations for Cisco NX-OS network devices based on specified options.
---
# Overview
The Cisco NX-OS Hardening Tool is a specialized security API designed to generate enterprise-grade hardening configurations for Cisco Nexus switches and NX-OS platforms. This tool helps network security teams and infrastructure engineers quickly produce validated security policies and configuration templates that align with industry best practices and security standards.
The tool accepts a set of hardening options and contextual metadata (session ID, user ID, and timestamp) to generate customized hardening configurations. It supports flexible option arrays, enabling teams to selectively apply security controls based on their specific environment and compliance requirements.
Ideal users include network engineers, security architects, DevOps teams managing Cisco infrastructure, and organizations requiring automated compliance configuration generation for Cisco Nexus environments.
## Usage
### Sample Request
```json
{
"sessionId": "sess_abc123def456",
"userId": 42,
"timestamp": "2025-01-15T10:30:00Z",
"hardeningOptions": {
"authentication": [
"enable_aaa",
"configure_radius",
"enforce_password_policy"
],
"access_control": [
"disable_telnet",
"enable_ssh_v2",
"restrict_console_access"
],
"logging": [
"enable_syslog",
"configure_ntp",
"audit_command_logging"
]
}
}
```
### Sample Response
```json
{
"status": "success",
"sessionId": "sess_abc123def456",
"userId": 42,
"timestamp": "2025-01-15T10:30:00Z",
"configuration": {
"authentication": {
"commands": [
"aaa new-model",
"radius server 192.168.1.100",
"password-policy min-length 12 uppercase lowercase digits special-chars"
]
},
"access_control": {
"commands": [
"no feature telnet",
"feature ssh",
"ssh key-length 2048",
"line console 0",
"access-class CONSOLE_ACL in"
]
},
"logging": {
"commands": [
"logging server 192.168.1.50 facility local7",
"ntp server 192.168.1.60 prefer",
"logging source-interface Loopback0",
"logging level aaa 6"
]
}
},
"appliedOptions": 9,
"warnings": []
}
```
## Endpoints
### GET /
**Summary:** Root endpoint health check
**Method:** GET
**Path:** `/`
**Description:** Returns basic API status information and confirms the service is operational.
**Parameters:** None
**Response:**
- **200 OK**: Service is operational
- **Content-Type:** `application/json`
---
### POST /api/hardening/generate
**Summary:** Generate hardening configuration
**Method:** POST
**Path:** `/api/hardening/generate`
**Description:** Generates Cisco NX-OS hardening configurations based on the provided options, session context, and user information. Processes multiple hardening categories and returns validated configuration commands.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `hardeningOptions` | Object (map of string → array of strings) | Yes | Dictionary of hardening categories with arrays of specific options. Keys represent categories (e.g., "authentication", "access_control"); values are arrays of option identifiers. |
| `sessionId` | String | Yes | Unique session identifier for tracking and audit purposes. |
| `userId` | Integer or null | No | Identifier of the user requesting the configuration. Optional for anonymous requests. |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp indicating when the request was made (e.g., "2025-01-15T10:30:00Z"). |
**Request Body Schema:**
```json
{
"hardeningOptions": {
"category_name": ["option1", "option2"]
},
"sessionId": "string",
"userId": null,
"timestamp": "2025-01-15T10:30:00Z"
}
```
**Responses:**
- **200 OK**: Configuration successfully generated
- **Content-Type:** `application/json`
- Returns hardening configuration with commands organized by category
- **422 Unprocessable Entity**: Validation error in request
- **Content-Type:** `application/json`
- Returns validation error details including field location, error message, and error type
**Example Error Response:**
```json
{
"detail": [
{
"loc": ["body", "sessionId"],
"msg": "field required",
"type": "value_error.missing"
}
]
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/cisco-nxos
- **API Docs:** https://api.mkkpro.com:8137/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cisco NX-OS Hardening Tool",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate",
"operationId": "generate_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional Docker security configuration generator aligned with CIS Benchmark v1.8.0 standards.
---
name: Docker Security Hardening Tool
description: Professional Docker security configuration generator aligned with CIS Benchmark v1.8.0 standards.
---
# Overview
The Docker Security Hardening Tool is a professional-grade API for generating CIS Benchmark-compliant Docker security configurations. It automates the creation of hardened Docker deployment manifests, security policies, and configuration files that align with industry-standard security best practices (CIS Benchmark v1.8.0).
This tool is essential for DevOps engineers, security teams, and infrastructure architects who need to rapidly deploy secure Docker environments without manual configuration. It eliminates guesswork by providing validated, benchmark-aligned configurations that can be immediately deployed to production systems.
The API provides intelligent option discovery, flexible configuration generation, and audit-ready output suitable for compliance documentation and security reviews.
## Usage
**Example Request:**
```json
{
"hardeningOptions": {
"image_security": ["scan_images", "minimal_base"],
"runtime_security": ["read_only_root", "no_privileged"],
"network_security": ["restrict_ports", "user_namespaces"]
},
"sessionId": "sess_abc123def456",
"userId": 12847,
"timestamp": "2025-01-15T10:30:00Z"
}
```
**Example Response:**
```json
{
"status": "success",
"configurationId": "config_xyz789",
"generatedFiles": {
"Dockerfile.hardened": "FROM alpine:3.18\nRUN addgroup -S appgroup && adduser -S appuser -G appgroup\nUSER appuser\nRUN chmod a-w /\nRUN chmod u+w /tmp /var/tmp\nENTRYPOINT [\"app\"]\n",
"docker-compose.hardened.yml": "version: '3.8'\nservices:\n app:\n image: myapp:hardened\n read_only: true\n security_opt:\n - no-new-privileges:true\n cap_drop:\n - ALL\n cap_add:\n - NET_BIND_SERVICE\n networks:\n - internal\nnetworks:\n internal:\n driver: bridge\n",
"security_policy.json": "{\n \"version\": \"1.0\",\n \"benchmark\": \"CIS Docker Benchmark v1.8.0\",\n \"policies\": [\n {\"id\": \"4.1\", \"description\": \"Ensure AppArmor Profile is Enabled\", \"status\": \"applied\"},\n {\"id\": \"4.5\", \"description\": \"Ensure default ulimit is set appropriately\", \"status\": \"applied\"}\n ]\n}\n"
},
"appliedPolicies": [
"4.1 - AppArmor enabled",
"4.5 - Ulimit restrictions",
"5.1 - Read-only root filesystem",
"5.27 - User namespace enabled"
],
"complianceScore": 94,
"recommendations": [
"Consider implementing runtime scanning with Falco for behavioral monitoring",
"Enable image scanning in your container registry"
],
"timestamp": "2025-01-15T10:30:15Z"
}
```
## Endpoints
### GET /
**Description:** Health check endpoint to verify API availability.
**Parameters:** None
**Response:**
```
200 OK - JSON object confirming service status
```
---
### POST /api/docker/hardening/generate
**Description:** Generate Docker security hardening configuration files based on specified options.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| hardeningOptions | object | Yes | Dictionary mapping security categories to option arrays. Keys represent security domains (e.g., "image_security", "runtime_security"), values are arrays of specific hardening techniques. |
| sessionId | string | Yes | Unique session identifier for tracking and audit purposes. |
| userId | integer or null | No | Optional user identifier for multi-tenant environments and usage tracking. |
| timestamp | string | Yes | ISO 8601 formatted timestamp of the request (e.g., "2025-01-15T10:30:00Z"). |
**Response Shape:**
```json
{
"status": "string",
"configurationId": "string",
"generatedFiles": {
"Dockerfile.hardened": "string",
"docker-compose.hardened.yml": "string",
"security_policy.json": "string"
},
"appliedPolicies": ["string"],
"complianceScore": "integer (0-100)",
"recommendations": ["string"],
"timestamp": "string"
}
```
---
### GET /api/docker/hardening/options
**Description:** Retrieve all available hardening options with descriptions, categories, and CIS Benchmark references.
**Parameters:** None
**Response Shape:**
```json
{
"imageSecurityOptions": [
{
"id": "string",
"name": "string",
"description": "string",
"cisBenchmarkId": "string"
}
],
"runtimeSecurityOptions": [...],
"networkSecurityOptions": [...],
"storageSecurityOptions": [...],
"version": "string",
"lastUpdated": "string"
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/docker
- **API Docs:** https://api.mkkpro.com:8136/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Docker Security Hardening Tool",
"description": "Professional Docker Security Configuration Generator - CIS Benchmark v1.8.0",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/docker/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Docker security hardening configuration files",
"operationId": "generate_hardening_config_api_docker_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/docker/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options with details",
"operationId": "get_hardening_options_api_docker_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional FortiGate security configuration generator based on CIS Benchmark standards for enterprise firewall hardening.
---
name: FortiGate Security Hardening Tool
description: Professional FortiGate security configuration generator based on CIS Benchmark standards for enterprise firewall hardening.
---
# Overview
The FortiGate Security Hardening Tool is a professional-grade API that generates hardened FortiGate firewall configurations aligned with CIS Benchmark security standards. Built for security teams, network architects, and compliance officers, this tool automates the creation of security configuration files that follow industry best practices and regulatory requirements.
This tool eliminates manual configuration errors and reduces deployment time by generating validated, production-ready FortiGate configurations. Organizations can quickly implement security hardening across their firewall infrastructure while maintaining consistency with established security frameworks. The API supports flexible configuration options, allowing teams to customize hardening profiles based on their specific security posture requirements and organizational policies.
Ideal users include enterprise security teams, managed security service providers (MSSPs), infrastructure-as-code practitioners, and compliance professionals who need to standardize and automate FortiGate security deployments at scale.
# Usage
**Generate a hardened FortiGate configuration with specific security options:**
```json
POST /api/fortigate/generate
{
"sessionId": "sess_abc123def456",
"userId": 42,
"timestamp": "2025-01-15T10:30:00Z",
"hardeningOptions": {
"firewall_policies": ["strict_inbound", "deny_by_default"],
"ssl_tls": ["tls_1_3_only", "strong_ciphers"],
"admin_access": ["disable_telnet", "https_only", "change_default_port"],
"logging": ["enable_threat_logging", "enable_traffic_logging"],
"authentication": ["enable_2fa", "strong_password_policy"]
}
}
```
**Sample Response:**
```json
{
"status": "success",
"configurationId": "cfg_xyz789abc123",
"timestamp": "2025-01-15T10:30:15Z",
"configuration": {
"firewall_rules": [
{
"name": "Default_Deny_Inbound",
"action": "deny",
"direction": "inbound",
"schedule": "always"
}
],
"ssl_tls_settings": {
"min_version": "TLSv1.3",
"cipher_suites": ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"]
},
"admin_settings": {
"telnet_enabled": false,
"http_enabled": false,
"https_enabled": true,
"admin_port": 8443
},
"logging": {
"threat_logging": true,
"traffic_logging": true,
"log_level": "information"
},
"authentication": {
"two_factor_enabled": true,
"password_policy": {
"min_length": 16,
"require_uppercase": true,
"require_numbers": true,
"require_special_chars": true
}
}
},
"download_url": "https://api.mkkpro.com/hardening/fortigate/cfg_xyz789abc123"
}
```
# Endpoints
## GET /
**Health Check Endpoint**
Performs a basic health check to verify API availability and connectivity.
**Parameters:** None
**Response:**
- Status: `200 OK`
- Content-Type: `application/json`
- Body: Health status object
---
## POST /api/fortigate/generate
**Generate FortiGate Security Configuration**
Generates a complete hardened FortiGate firewall configuration file based on provided hardening options and CIS Benchmark standards.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `hardeningOptions` | Object | Yes | A dictionary mapping hardening categories to arrays of specific hardening options. Example categories: `firewall_policies`, `ssl_tls`, `admin_access`, `logging`, `authentication`. Each value is an array of string option names. |
| `sessionId` | String | Yes | Unique session identifier for tracking and audit purposes. |
| `userId` | Integer or Null | No | Optional user ID associated with the configuration generation request. |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp of the request (e.g., `2025-01-15T10:30:00Z`). |
**Response:**
- Status: `200 OK` on success, `422 Unprocessable Entity` on validation error
- Content-Type: `application/json`
- Body:
```json
{
"status": "success",
"configurationId": "string",
"timestamp": "string",
"configuration": {
"firewall_rules": "array",
"ssl_tls_settings": "object",
"admin_settings": "object",
"logging": "object",
"authentication": "object"
},
"download_url": "string"
}
```
---
## GET /api/fortigate/options
**Retrieve Available FortiGate Hardening Options**
Returns a comprehensive list of all available FortiGate hardening configuration options, allowing clients to discover supported parameters before generating configurations.
**Parameters:** None
**Response:**
- Status: `200 OK`
- Content-Type: `application/json`
- Body: Object containing available hardening categories and their supported options:
```json
{
"firewall_policies": ["strict_inbound", "deny_by_default", "log_all_traffic"],
"ssl_tls": ["tls_1_3_only", "strong_ciphers", "disable_weak_protocols"],
"admin_access": ["disable_telnet", "https_only", "change_default_port", "restrict_admin_ips"],
"logging": ["enable_threat_logging", "enable_traffic_logging", "centralized_logging"],
"authentication": ["enable_2fa", "strong_password_policy", "disable_default_accounts"]
}
```
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/fortigate
- **API Docs:** https://api.mkkpro.com:8135/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "FortiGate Security Hardening Tool",
"description": "Professional FortiGate Security Configuration Generator based on CIS Benchmark",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/fortigate/generate": {
"post": {
"summary": "Generate Fortigate Config",
"description": "Generate FortiGate security hardening configuration files",
"operationId": "generate_fortigate_config_api_fortigate_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/fortigate/options": {
"get": {
"summary": "Get Fortigate Options",
"description": "Get all available FortiGate hardening options",
"operationId": "get_fortigate_options_api_fortigate_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional network switch security configuration generator compliant with CIS Benchmark standards for Aruba CX switches.
---
name: Aruba CX Switch Security Hardening Tool
description: Professional network switch security configuration generator compliant with CIS Benchmark standards for Aruba CX switches.
---
# Overview
The Aruba CX Switch Security Hardening Tool is a professional-grade API designed to generate security-hardened configuration files for Aruba CX network switches. Built by security-certified professionals, this tool automates the process of applying CIS Benchmark compliance standards to your switch infrastructure, eliminating manual configuration errors and ensuring consistent security posture across your network.
This tool is ideal for network administrators, security teams, and infrastructure engineers who manage Aruba CX deployments and need to rapidly deploy security best practices. It eliminates the need for manual hardening procedures by generating ready-to-deploy configuration files tailored to your specific security requirements.
The API provides comprehensive hardening options covering authentication, encryption, access controls, logging, and network segmentation—all aligned with industry-recognized security standards. Simply specify your hardening preferences, and receive validated, production-ready configuration files instantly.
# Usage
## Sample Request
```json
{
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"userId": 12345,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"authentication": ["enable_tacacs", "enforce_strong_passwords"],
"encryption": ["enable_ssh_v2", "disable_telnet"],
"access_control": ["restrict_snmp_v1", "enable_port_security"],
"logging": ["enable_syslog", "audit_login_events"],
"network": ["enable_vlan_separation", "configure_dhcp_snooping"]
}
}
```
## Sample Response
```json
{
"status": "success",
"configurationId": "cfg_987xyz654abc",
"generatedAt": "2024-01-15T14:30:15Z",
"hardeningProfile": "Enterprise-Standard",
"configFiles": [
{
"filename": "authentication.conf",
"content": "aaa authentication login default tacacs+ local\naaa authentication enable default tacacs+ enable\npassword-policy minimum-length 12\npassword-policy complexity require-mixed-case\npassword-policy complexity require-numbers\n...",
"format": "Aruba CX CLI"
},
{
"filename": "encryption.conf",
"content": "ip ssh version 2\nno service telnet\nline vty 0 4\n transport input ssh\n...",
"format": "Aruba CX CLI"
},
{
"filename": "access_control.conf",
"content": "snmp-server community public RO 1.1.1.0 255.255.255.0\nno snmp-server community private RW\nport-security enable\n...",
"format": "Aruba CX CLI"
},
{
"filename": "logging.conf",
"content": "logging 192.168.1.100\nlogging facility local0\nlogging trap informational\naudit-log enable\naudit-log event login\n...",
"format": "Aruba CX CLI"
}
],
"benchmarkCompliance": {
"cisVersion": "CIS Aruba CX 10.x Benchmark v1.2",
"controlsCovered": 47,
"controlsPassed": 47,
"compliancePercentage": 100
},
"securitySummary": {
"categoriesCovered": 5,
"criticalControls": 12,
"highControls": 18,
"mediumControls": 17
}
}
```
# Endpoints
## GET /
**Health check endpoint**
Health check to verify API availability and connectivity.
**Parameters:** None
**Response:** Status confirmation in JSON format.
---
## POST /api/aruba/hardening/generate
**Generate Aruba CX Switch security hardening configuration files**
Generates CIS Benchmark-compliant security hardening configurations based on your specified hardening options. Returns ready-to-deploy configuration files for authentication, encryption, access controls, logging, and network security.
**Request Body (application/json):**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | object | ✓ | Dictionary mapping security categories to arrays of hardening controls. Keys include: `authentication`, `encryption`, `access_control`, `logging`, `network`. Values are arrays of control names (strings). |
| `sessionId` | string | ✓ | Unique session identifier for tracking and audit purposes. |
| `userId` | integer \| null | ✗ | Optional user ID for request attribution and usage analytics. |
| `timestamp` | string | ✓ | ISO 8601 formatted timestamp of request generation (e.g., `2024-01-15T14:30:00Z`). |
**Response:** JSON object containing:
- `status`: Request status (success/error)
- `configurationId`: Unique identifier for generated configuration
- `generatedAt`: Timestamp of generation
- `hardeningProfile`: Applied security profile
- `configFiles`: Array of configuration file objects with `filename`, `content`, and `format`
- `benchmarkCompliance`: CIS compliance details and control coverage
- `securitySummary`: Summary of implemented security controls by severity
**Error Response (422):** Validation error with details array containing invalid fields.
---
## GET /api/aruba/hardening/options
**Get all available hardening options**
Retrieves the complete list of available hardening controls and categories that can be specified in configuration generation requests.
**Parameters:** None
**Response:** JSON object containing available hardening categories and their supported controls:
- `authentication`: Available authentication hardening options
- `encryption`: Available encryption and transport security options
- `access_control`: Available access control mechanisms
- `logging`: Available logging and audit options
- `network`: Available network security options
Each category contains an array of supported control identifiers that can be referenced in `/api/aruba/hardening/generate` requests.
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/aruba-cx
- **API Docs:** https://api.mkkpro.com:8134/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Aruba CX Switch Security Hardening Tool",
"description": "Professional Network Switch Security Configuration Generator - CIS Benchmark Compliant",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/aruba/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Aruba CX Switch security hardening configuration files",
"operationId": "generate_hardening_config_api_aruba_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/aruba/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_aruba_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional Juniper Network Security Configuration Generator for enterprise-grade network hardening.
---
name: Juniper OS Security Hardening Tool
description: Professional Juniper Network Security Configuration Generator for enterprise-grade network hardening.
---
# Overview
The Juniper OS Security Hardening Tool is a professional-grade API that generates production-ready security hardening configurations for Juniper Networks devices. Designed for network security engineers and infrastructure teams, this tool automates the creation of security policies, access controls, and hardened baseline configurations aligned with industry best practices and compliance standards.
This tool streamlines the deployment of security configurations across Juniper environments by providing templated, validated hardening options that reduce manual configuration errors and accelerate security implementation timelines. The API returns ready-to-deploy configuration files that can be directly applied to Juniper OS systems.
Ideal users include network administrators, security architects, DevSecOps engineers, and compliance teams responsible for maintaining secure Juniper network infrastructure in enterprise, government, and regulated industry environments.
# Usage
**Example Request:**
Generate a hardening configuration with SSH lockdown and firewall policy options:
```json
{
"hardeningOptions": {
"sshConfig": ["disable-password-auth", "change-default-port"],
"firewallPolicy": ["block-all-inbound", "enable-stateful-inspection"],
"authentication": ["enable-mfa", "enforce-strong-passwords"]
},
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"userId": 12345,
"timestamp": "2025-01-15T14:30:00Z"
}
```
**Example Response:**
```json
{
"status": "success",
"configId": "cfg_9x8y7z6a5b4c3d2e",
"hardeningConfiguration": {
"sshConfig": {
"passwordAuthentication": "no",
"port": "2222",
"protocol": "2",
"permitRootLogin": "no",
"x11Forwarding": "no"
},
"firewallPolicy": {
"defaultInboundPolicy": "deny",
"statefulInspection": "enabled",
"loggingLevel": "info"
},
"authentication": {
"multiFactorAuth": "enabled",
"passwordMinLength": 16,
"passwordExpiry": 90
}
},
"configurationFile": "set system host-name juniper-hardened\nset system time-zone UTC\nset system services ssh...",
"appliedAt": "2025-01-15T14:30:15Z",
"timestamp": "2025-01-15T14:30:15Z"
}
```
# Endpoints
## GET /
**Health Check Endpoint**
Returns the health status of the API service.
**Parameters:** None
**Response:**
```
Status: 200 OK
Content-Type: application/json
{
"status": "operational",
"version": "1.0.0"
}
```
---
## POST /api/juniper/generate
**Generate Hardening Configuration**
Generates production-ready Juniper OS security hardening configuration files based on specified hardening options.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| hardeningOptions | Object (string arrays) | Yes | Key-value map of hardening categories to option arrays. Keys represent configuration domains (e.g., sshConfig, firewallPolicy, authentication), values are arrays of specific hardening measures to apply. |
| sessionId | String | Yes | Unique session identifier for request tracking and audit logging. |
| userId | Integer or Null | No | Optional user identifier for attribution and usage analytics. |
| timestamp | String | Yes | ISO 8601 formatted timestamp (e.g., 2025-01-15T14:30:00Z) marking request creation time. |
**Response (200):**
```
Content-Type: application/json
{
"status": "success",
"configId": "string",
"hardeningConfiguration": { ... },
"configurationFile": "string",
"appliedAt": "string",
"timestamp": "string"
}
```
**Response (422 - Validation Error):**
```
Content-Type: application/json
{
"detail": [
{
"loc": ["body", "sessionId"],
"msg": "field required",
"type": "value_error.missing"
}
]
}
```
---
## GET /api/juniper/options
**Get Hardening Options**
Retrieves all available Juniper hardening configuration options, categories, and valid parameter values.
**Parameters:** None
**Response (200):**
```
Content-Type: application/json
{
"sshConfig": [
"disable-password-auth",
"change-default-port",
"disable-root-login",
"disable-x11-forwarding",
"enforce-key-exchange-algorithms"
],
"firewallPolicy": [
"block-all-inbound",
"enable-stateful-inspection",
"enable-dos-protection",
"enforce-connection-limiting"
],
"authentication": [
"enable-mfa",
"enforce-strong-passwords",
"enable-account-lockout",
"set-password-expiry"
],
"syslog": [
"enable-centralized-logging",
"set-log-retention-90-days"
],
"snmp": [
"disable-snmpv2",
"enforce-snmpv3-encryption"
]
}
```
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/juniper
- **API Docs:** https://api.mkkpro.com:8133/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Juniper OS Security Hardening Tool",
"description": "Professional Juniper Network Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/juniper/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Juniper OS security hardening configuration files",
"operationId": "generate_hardening_config_api_juniper_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/juniper/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available Juniper hardening options",
"operationId": "get_hardening_options_api_juniper_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional PAN-OS security configuration generator for hardening Palo Alto firewalls with industry best practices.
---
name: Palo Alto Firewall Hardening Tool
description: Professional PAN-OS security configuration generator for hardening Palo Alto firewalls with industry best practices.
---
# Overview
The Palo Alto Firewall Hardening Tool is a professional-grade security configuration generator designed to automate the creation of hardened Palo Alto Networks (PAN-OS) firewall configurations. This tool eliminates manual configuration errors and ensures compliance with security best practices by generating optimized security policy files based on your specific hardening requirements.
The tool provides comprehensive configuration generation capabilities, allowing security teams to select from a wide range of hardening options and instantly receive production-ready PAN-OS configuration snippets. It supports advanced features including session tracking, user attribution, and timestamp logging for audit compliance and change management workflows.
Ideal users include security architects, firewall administrators, compliance officers, and DevSecOps teams who need to rapidly deploy secure Palo Alto firewall configurations across their infrastructure while maintaining consistency and adhering to industry security standards.
# Usage
**Sample Request:**
```json
{
"sessionId": "sess_abc123def456",
"userId": 42,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"threat_prevention": ["antivirus", "anti-spyware", "vulnerability_protection"],
"ssl_tls": ["tls_1_2_minimum", "strong_ciphers"],
"authentication": ["multi_factor", "password_complexity"],
"logging": ["all_traffic", "threat_events", "admin_actions"]
}
}
```
**Sample Response:**
```json
{
"status": "success",
"configurationId": "config_xyz789",
"timestamp": "2024-01-15T14:30:15Z",
"hardeningProfile": {
"threatPrevention": {
"antiVirus": "enabled",
"antiSpyware": "enabled",
"vulnerabilityProtection": "enabled"
},
"sslTls": {
"minimumVersion": "TLS 1.2",
"cipherStrength": "strong"
},
"authentication": {
"mfa": "enabled",
"passwordPolicy": {
"minimumLength": 14,
"complexity": "high"
}
},
"logging": {
"trafficLogging": "enabled",
"threatEventLogging": "enabled",
"adminActionLogging": "enabled"
}
},
"configurationFile": "<?xml version=\"1.0\"?>...",
"deploymentInstructions": "Upload configuration via Panorama or direct management interface"
}
```
# Endpoints
## GET /
**Description:** Health check endpoint for service availability verification.
**Method:** GET
**Path:** /
**Parameters:** None
**Response:** Returns HTTP 200 with service status confirmation.
---
## POST /api/paloalto/generate
**Description:** Generate hardened Palo Alto firewall configuration files based on specified hardening options.
**Method:** POST
**Path:** /api/paloalto/generate
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| hardeningOptions | object | Yes | Key-value mapping of hardening categories to arrays of specific options (e.g., `{"threat_prevention": ["antivirus", "anti-spyware"]}`) |
| sessionId | string | Yes | Unique session identifier for audit trail and rate limiting tracking |
| userId | integer | No | User ID for attribution and audit logging purposes |
| timestamp | string | Yes | ISO 8601 formatted timestamp indicating request time (e.g., `2024-01-15T14:30:00Z`) |
**Response:** Returns HTTP 200 with generated PAN-OS configuration file, configuration ID, hardening profile details, and deployment instructions. On validation error (422), returns HTTPValidationError with detailed field-level error information.
---
## GET /api/paloalto/options
**Description:** Retrieve all available hardening options and categories supported by the configuration generator.
**Method:** GET
**Path:** /api/paloalto/options
**Parameters:** None
**Response:** Returns HTTP 200 with comprehensive list of available hardening categories, individual options within each category, and descriptions of each option for reference when building requests.
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- Kong Route: https://api.mkkpro.com/hardening/palo-alto
- API Docs: https://api.mkkpro.com:8132/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Palo Alto Firewall Hardening Tool",
"description": "Professional PAN-OS Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/paloalto/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Palo Alto firewall hardening configuration files",
"operationId": "generate_hardening_config_api_paloalto_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/paloalto/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_paloalto_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates hardened pfSense firewall configurations based on specified security options.
---
name: pfSense Hardening Tool
description: Generates hardened pfSense firewall configurations based on specified security options.
---
# Overview
The pfSense Hardening Tool is a security-focused API that automates the generation of hardened configurations for pfSense firewalls. Built by CISSP and CISM certified professionals, this tool enables network administrators and security engineers to quickly apply industry best practices and security hardening standards to their pfSense deployments without manual configuration.
The tool accepts a set of hardening options and generates optimized pfSense configurations tailored to your security requirements. It supports session tracking, user identification, and timestamped requests to ensure audit compliance and change management. Whether you're deploying a new pfSense instance or enhancing an existing firewall, this tool streamlines the hardening process and reduces configuration errors.
Ideal users include network security teams, DevSecOps engineers, managed security service providers (MSSPs), and organizations seeking to standardize their firewall security posture across multiple pfSense installations.
## Usage
**Sample Request:**
```json
{
"hardeningOptions": {
"firewall_rules": ["block_all_inbound", "restrict_ssh_access"],
"ssl_tls": ["disable_sslv3", "enable_tls_1_2_minimum"],
"logging": ["enable_firewall_logging", "enable_dhcp_logging"]
},
"sessionId": "sess_a7f9d3c2b1e4f6h8",
"userId": 42,
"timestamp": "2025-01-15T14:30:00Z"
}
```
**Sample Response:**
```json
{
"status": "success",
"configurationId": "config_9x2k5m8l1p4q7r3t",
"hardeningApplied": {
"firewall_rules": ["block_all_inbound", "restrict_ssh_access"],
"ssl_tls": ["disable_sslv3", "enable_tls_1_2_minimum"],
"logging": ["enable_firewall_logging", "enable_dhcp_logging"]
},
"generatedConfig": {
"version": "2.7.0",
"firewall": {
"rules": [
{
"id": 1,
"action": "block",
"direction": "in",
"description": "Block all inbound traffic by default"
}
]
},
"system": {
"ssl_tls_version": "1.2",
"logging_enabled": true
}
},
"timestamp": "2025-01-15T14:30:15Z",
"sessionId": "sess_a7f9d3c2b1e4f6h8"
}
```
## Endpoints
### POST /api/hardening/generate
**Description:** Generates a hardened pfSense configuration based on provided hardening options.
**Method:** POST
**Path:** `/api/hardening/generate`
**Request Body:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | Object (string array values) | **Required** | A map of hardening categories to arrays of hardening rules to apply. Examples: `firewall_rules`, `ssl_tls`, `logging`, `access_control`, etc. |
| `sessionId` | String | **Required** | Unique identifier for the current session, used for audit tracking and request correlation. |
| `userId` | Integer | Optional | User ID of the administrator requesting the hardened configuration. |
| `timestamp` | String | **Required** | ISO 8601 formatted timestamp indicating when the request was generated (e.g., `2025-01-15T14:30:00Z`). |
**Response (200 - Success):**
The endpoint returns a JSON object containing:
- `status`: String indicating success or failure
- `configurationId`: Unique identifier for the generated configuration
- `hardeningApplied`: Echo of the hardening options that were applied
- `generatedConfig`: The complete hardened pfSense configuration object
- `timestamp`: Server-side timestamp of the response
- `sessionId`: Echo of the provided session ID for correlation
**Response (422 - Validation Error):**
Returns an `HTTPValidationError` object with a `detail` array containing validation errors:
| Field | Type | Description |
|-------|------|-------------|
| `detail` | Array | Array of validation error objects |
| `detail[].loc` | Array | Location of the validation error (field path) |
| `detail[].msg` | String | Human-readable error message |
| `detail[].type` | String | Error type identifier |
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- Kong Route: https://api.mkkpro.com/hardening/pfsense
- API Docs: https://api.mkkpro.com:8131/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "pfSense Hardening Tool",
"version": "1.0.0"
},
"paths": {
"/api/hardening/generate": {
"post": {
"summary": "Generate",
"operationId": "generate_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Request"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"Request": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"type": "integer",
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "Request"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional Ubuntu 22.04 LTS security configuration generator for STIG-compliant hardening.
---
name: Ubuntu Linux Security Hardening Tool
description: Professional Ubuntu 22.04 LTS security configuration generator for STIG-compliant hardening.
---
# Overview
The Ubuntu Linux Security Hardening Tool is a professional-grade security configuration generator designed for Ubuntu 22.04 LTS systems. It automates the creation of STIG-compliant hardening configurations, eliminating manual security baseline setup and reducing human error in system hardening processes.
This tool enables security engineers, system administrators, and DevOps teams to generate comprehensive hardening configuration files tailored to their specific security requirements. By leveraging industry-standard hardening categories and options, users can quickly deploy security best practices across their infrastructure while maintaining compliance with established security frameworks.
The tool is ideal for organizations implementing Zero Trust architectures, preparing for security audits, managing multi-server deployments, or standardizing security baselines across development, staging, and production environments.
# Usage
## Example Request
Generate a hardening configuration with kernel hardening, SSH security, and firewall policies enabled:
```json
{
"hardeningOptions": {
"kernel_hardening": [
"kptr_restrict",
"dmesg_restrict",
"unprivileged_namespaces"
],
"ssh_security": [
"disable_password_auth",
"disable_root_login",
"change_default_port"
],
"firewall": [
"enable_ufw",
"default_deny_incoming"
]
},
"sessionId": "sess_a1b2c3d4e5f6g7h8",
"userId": 12345,
"timestamp": "2024-01-15T10:30:00Z"
}
```
## Example Response
```json
{
"status": "success",
"configId": "cfg_9x8y7w6v5u4t3s2r",
"timestamp": "2024-01-15T10:30:15Z",
"configurations": {
"kernel_hardening": {
"file": "hardening-kernel.conf",
"settings": [
{
"parameter": "kernel.kptr_restrict",
"value": "2",
"description": "Hide kernel pointers in dmesg and /proc"
},
{
"parameter": "kernel.dmesg_restrict",
"value": "1",
"description": "Restrict dmesg access to root only"
},
{
"parameter": "kernel.unprivileged_userns_clone",
"value": "0",
"description": "Disable unprivileged user namespaces"
}
]
},
"ssh_security": {
"file": "hardening-sshd_config",
"settings": [
{
"directive": "PasswordAuthentication",
"value": "no",
"description": "Disable password-based authentication"
},
{
"directive": "PermitRootLogin",
"value": "no",
"description": "Disable direct root login"
},
{
"directive": "Port",
"value": "2222",
"description": "Change SSH listening port from default 22"
}
]
},
"firewall": {
"file": "hardening-ufw.rules",
"settings": [
{
"command": "ufw enable",
"description": "Enable UFW firewall"
},
{
"command": "ufw default deny incoming",
"description": "Set default policy to deny all incoming"
}
]
}
},
"totalConfigurations": 3,
"downloadUrl": "https://api.mkkpro.com/hardening/ubuntu-v2/cfg_9x8y7w6v5u4t3s2r/download"
}
```
# Endpoints
## GET /
**Description:** Health check endpoint to verify API availability.
**Parameters:** None
**Response:**
- Status 200: JSON object confirming API health status
---
## POST /api/hardening/generate
**Description:** Generate Ubuntu security hardening configuration files based on specified hardening options.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| hardeningOptions | Object | Yes | Map of hardening categories to arrays of specific options to enable. Categories may include: `kernel_hardening`, `ssh_security`, `firewall`, `apparmor`, `audit_logging`, `user_account_security`, `file_permissions`, `network_hardening` |
| sessionId | String | Yes | Unique session identifier for tracking and logging purposes |
| userId | Integer or null | No | Optional user identifier for audit trail and usage tracking |
| timestamp | String | Yes | ISO 8601 formatted timestamp when the request is generated |
**Response:**
- Status 200: JSON object containing generated configurations, config ID, and download URL
- Status 422: Validation error with details about invalid request parameters
---
## GET /api/hardening/options
**Description:** Retrieve all available hardening options across all categories that can be used in configuration generation.
**Parameters:** None
**Response:**
- Status 200: JSON object containing complete list of all hardening categories and their available options with descriptions
---
## GET /api/hardening/categories
**Description:** Retrieve hardening categories and their associated options for use in building hardening requests.
**Parameters:** None
**Response:**
- Status 200: JSON object containing structured hardening categories, available options within each category, and option metadata including descriptions and impact levels
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/ubuntu-v2
- **API Docs:** https://api.mkkpro.com:8129/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Ubuntu Linux Security Hardening Tool",
"description": "Professional Ubuntu 22.04 LTS Security Configuration Generator - STIG Compliant",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Ubuntu security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/categories": {
"get": {
"summary": "Get Categories",
"description": "Get hardening categories and their options",
"operationId": "get_categories_api_hardening_categories_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates professional Linux security hardening configuration files for Ubuntu systems with customizable options.
---
name: Ubuntu Linux Security Hardening Tool
description: Generates professional Linux security hardening configuration files for Ubuntu systems with customizable options.
---
# Overview
The Ubuntu Linux Security Hardening Tool is a professional-grade security configuration generator designed for system administrators, DevOps engineers, and security professionals who need to rapidly deploy hardened Ubuntu Linux environments. This tool eliminates manual configuration work by generating battle-tested security hardening scripts and configuration files tailored to your specific requirements.
The tool provides a comprehensive approach to Linux security by offering multiple hardening vectors including kernel parameters, firewall rules, authentication policies, service hardening, and system auditing configurations. Whether you're securing a single server, building infrastructure-as-code templates, or establishing security baselines across your organization, this tool accelerates deployment while maintaining industry best practices.
Ideal users include DevOps teams automating infrastructure deployments, security professionals conducting hardening assessments, system administrators managing enterprise Linux fleets, and organizations seeking compliance with CIS Benchmarks and NIST guidelines.
# Usage
**Example Request:**
```json
{
"sessionId": "sess_abc123def456",
"userId": 1001,
"timestamp": "2024-01-15T10:30:00Z",
"hardeningOptions": {
"kernel": ["disable_ipv6", "restrict_kernel_modules"],
"firewall": ["enable_ufw", "default_deny_incoming"],
"authentication": ["enforce_strong_passwords", "disable_root_login"],
"services": ["disable_unnecessary_services", "harden_ssh"],
"audit": ["enable_auditd", "log_file_access"]
}
}
```
**Example Response:**
```json
{
"status": "success",
"sessionId": "sess_abc123def456",
"generatedAt": "2024-01-15T10:30:05Z",
"configFiles": [
{
"filename": "10-kernel-hardening.conf",
"path": "/etc/sysctl.d/",
"content": "kernel.kptr_restrict = 2\nkernel.unprivileged_userns_clone = 0\nnet.ipv6.conf.all.disable_ipv6 = 1\n..."
},
{
"filename": "sshd_config.hardened",
"path": "/etc/ssh/",
"content": "PermitRootLogin no\nPasswordAuthentication no\nX11Forwarding no\n..."
},
{
"filename": "ufw-rules.sh",
"path": "/root/",
"content": "#!/bin/bash\nufw default deny incoming\nufw default allow outgoing\n..."
}
],
"summary": {
"totalFiles": 3,
"hardeningCategories": 5,
"estimatedImplementationTime": "15 minutes",
"complianceFrameworks": ["CIS Benchmark", "NIST 800-53"]
}
}
```
# Endpoints
## GET /
**Description:** Health check endpoint for service availability verification.
**Parameters:** None
**Response:** JSON object indicating service status.
---
## POST /api/hardening/generate
**Description:** Generates Ubuntu Linux security hardening configuration files based on selected hardening options.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `hardeningOptions` | Object (string arrays) | Yes | Dictionary of hardening categories and their selected options. Keys represent categories (e.g., "kernel", "firewall", "authentication"), values are arrays of specific hardening measures. |
| `sessionId` | String | Yes | Unique session identifier for tracking and audit purposes. |
| `userId` | Integer or null | No | Optional user identifier for multi-tenant environments and usage attribution. |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp indicating when the request was generated. |
**Response:**
- **Status 200:** Returns generated hardening configuration files with content, paths, implementation summary, and compliance framework mappings.
- **Status 422:** Validation error. Response includes detailed error messages for malformed requests.
---
## GET /api/hardening/options
**Description:** Retrieves all available hardening options and categories supported by the tool.
**Parameters:** None
**Response:** JSON object containing:
- Available hardening categories (kernel, firewall, authentication, services, audit, etc.)
- Specific hardening options within each category
- Descriptions and impact levels for each option
- Compatibility notes and dependencies between options
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- Kong Route: https://api.mkkpro.com/hardening/ubuntu
- API Docs: https://api.mkkpro.com:8128/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Ubuntu Linux Security Hardening Tool",
"description": "Professional Linux Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Ubuntu Linux security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Enterprise-grade API for generating optimized Active Directory security configuration files with hardening best practices.
---
name: Active Directory Hardening Tool
description: Enterprise-grade API for generating optimized Active Directory security configuration files with hardening best practices.
---
# Overview
The Active Directory Hardening Tool is an enterprise-grade security API designed to generate comprehensive Active Directory (AD) hardening configuration files based on industry best practices and CISSP-aligned security standards. This tool automates the complex process of configuring AD security settings, reducing manual configuration errors and ensuring consistent security posture across AD environments.
Organizations managing large-scale Active Directory deployments require robust security configurations to protect against lateral movement, privilege escalation, and unauthorized access. This tool streamlines the generation of hardening configurations by accepting flexible hardening options and producing deployment-ready configuration files. It is ideal for security architects, system administrators, and organizations undergoing AD security assessments or compliance initiatives.
The API provides enumeration of available hardening options, allowing teams to understand all supported configurations before generating customized hardening profiles. This enables organizations to tailor security configurations to their specific risk profiles and operational requirements.
# Usage
## Sample Request
Generate an AD hardening configuration with multiple security options:
```json
{
"sessionId": "sess_abc123def456",
"userId": 12345,
"timestamp": "2025-01-15T10:30:00Z",
"hardeningOptions": {
"passwordPolicy": ["enforceComplexity", "minLength14", "historyCount24"],
"accountLockout": ["threshold5", "duration30minutes", "resetCounterAfter30"],
"kerberosHardening": ["enableAESEncryption", "disableRC4", "setMaxTicketLifetime"],
"groupPolicy": ["enableAudit", "disableAnonymousAccess", "restrictNetworkAccess"]
}
}
```
## Sample Response
```json
{
"status": "success",
"configurationId": "config_xyz789uvw",
"timestamp": "2025-01-15T10:30:15Z",
"configurations": {
"passwordPolicy": {
"enforceComplexity": true,
"minimumLength": 14,
"passwordHistoryCount": 24,
"maximumPasswordAge": 90
},
"accountLockout": {
"lockoutThreshold": 5,
"lockoutDuration": 30,
"resetCounterAfterMinutes": 30
},
"kerberosHardening": {
"encryptionTypes": ["AES256", "AES128"],
"disabledEncryption": ["RC4"],
"maxTicketLifetimeHours": 10
},
"groupPolicy": {
"auditingEnabled": true,
"anonymousAccessDisabled": true,
"networkAccessRestricted": true
}
},
"deploymentScript": "powershell_script_content_here",
"auditLog": {
"requestId": "req_123456",
"userId": 12345,
"action": "AD_HARDENING_GENERATED",
"timestamp": "2025-01-15T10:30:15Z"
}
}
```
# Endpoints
## GET /
**Health Check Endpoint**
Verifies API availability and returns service status.
**Method:** GET
**Path:** `/`
**Parameters:** None
**Response:**
- **Status Code:** 200
- **Content-Type:** application/json
- **Body:** Service status object confirming API health
---
## POST /api/ad-hardening/generate
**Generate AD Hardening Configuration**
Generates enterprise-ready Active Directory hardening configuration files based on specified security options. Returns deployable configurations and scripts.
**Method:** POST
**Path:** `/api/ad-hardening/generate`
**Request Body (application/json):**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `hardeningOptions` | Object (string arrays) | Yes | Map of hardening categories to configuration options. Keys represent hardening domains (e.g., passwordPolicy, accountLockout, kerberosHardening); values are arrays of specific settings to apply. |
| `sessionId` | String | Yes | Unique session identifier for request tracking and audit logging. Used to correlate multiple requests within a session. |
| `userId` | Integer \| null | No | Optional user identifier for audit trail association. Useful for tracking which user generated the configuration. |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp of request generation. Must be in UTC format (e.g., "2025-01-15T10:30:00Z"). |
**Response:**
- **Status Code:** 200
- **Content-Type:** application/json
- **Body:** Configuration object containing hardened AD settings, deployment scripts, and audit trail metadata
- **Status Code:** 422 (on validation error)
- **Content-Type:** application/json
- **Body:** HTTPValidationError object with detailed field-level validation errors
---
## GET /api/ad-hardening/options
**Retrieve Available Hardening Options**
Enumerates all supported Active Directory hardening options, categories, and their descriptions. Use this endpoint to discover available configurations before generating hardening profiles.
**Method:** GET
**Path:** `/api/ad-hardening/options`
**Parameters:** None
**Response:**
- **Status Code:** 200
- **Content-Type:** application/json
- **Body:** Object containing hierarchical hardening options with descriptions:
- Available hardening categories (passwordPolicy, accountLockout, kerberosHardening, groupPolicy, etc.)
- Supported settings within each category
- Parameter descriptions and recommended values
- Security impact and compliance mappings
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/hardening/active-directory
- **API Documentation:** https://api.mkkpro.com:8127/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Active Directory Hardening Tool",
"description": "Enterprise-Grade AD Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/ad-hardening/generate": {
"post": {
"summary": "Generate Ad Hardening",
"description": "Generate AD hardening configuration files",
"operationId": "generate_ad_hardening_api_ad_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/ad-hardening/options": {
"get": {
"summary": "Get Ad Hardening Options",
"description": "Get all available AD hardening options",
"operationId": "get_ad_hardening_options_api_ad_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates security hardening recommendations and configurations for Kubernetes clusters based on specified hardening options.
---
name: Kubernetes Hardening Tool
description: Generates security hardening recommendations and configurations for Kubernetes clusters based on specified hardening options.
---
# Overview
The Kubernetes Hardening Tool is a security-focused API that generates comprehensive hardening recommendations and configurations for Kubernetes environments. Designed for DevSecOps teams, security engineers, and infrastructure professionals, this tool automates the process of identifying and implementing security best practices across Kubernetes clusters.
The tool accepts detailed hardening preferences and contextual information, then returns tailored security configurations and recommendations. It integrates seamlessly into CI/CD pipelines, infrastructure-as-code workflows, and security compliance frameworks, enabling organizations to maintain consistent, audit-ready Kubernetes security postures.
Ideal users include security teams implementing CIS Kubernetes Benchmarks, platform engineers building secure multi-tenant clusters, and compliance-focused organizations requiring documented hardening strategies.
## Usage
### Sample Request
```json
{
"sessionId": "sess_abc123def456",
"userId": 1001,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"rbac": ["enable-strict-policies", "service-account-isolation"],
"network": ["deny-all-ingress", "deny-all-egress", "enable-network-policies"],
"pod-security": ["restrict-privileged-containers", "enforce-read-only-filesystem"],
"audit": ["enable-audit-logging", "log-authentication-events"]
}
}
```
### Sample Response
```json
{
"status": "success",
"sessionId": "sess_abc123def456",
"timestamp": "2024-01-15T14:30:15Z",
"hardeningConfigurations": {
"rbac": {
"policies": [
{
"kind": "ClusterRole",
"name": "restricted-viewer",
"rules": [
{
"apiGroups": [""],
"resources": ["pods"],
"verbs": ["get", "list"]
}
]
}
],
"serviceAccounts": ["default-restricted"]
},
"network": {
"networkPolicies": [
{
"apiVersion": "networking.k8s.io/v1",
"kind": "NetworkPolicy",
"metadata": { "name": "deny-all-ingress" },
"spec": {
"podSelector": {},
"policyTypes": ["Ingress"]
}
}
]
},
"pod-security": {
"policies": [
{
"apiVersion": "policy/v1beta1",
"kind": "PodSecurityPolicy",
"metadata": { "name": "restricted" },
"spec": {
"privileged": false,
"readOnlyRootFilesystem": true
}
}
]
},
"audit": {
"auditPolicy": {
"apiVersion": "audit.k8s.io/v1",
"kind": "Policy",
"rules": [
{
"level": "RequestResponse",
"omitStages": ["RequestReceived"],
"resources": ["secrets"]
}
]
}
}
},
"recommendations": [
"Enable Pod Security Standards in addition to deprecated PodSecurityPolicy",
"Implement OPA/Gatekeeper for policy enforcement",
"Configure encrypted secrets at rest"
]
}
```
## Endpoints
### POST /api/hardening/generate
Generates comprehensive Kubernetes hardening configurations and security recommendations based on provided hardening options and session context.
**Method:** POST
**Path:** `/api/hardening/generate`
**Description:** Analyzes the specified hardening options and generates Kubernetes security configurations including RBAC policies, network policies, pod security policies, and audit logging settings.
#### Parameters
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `sessionId` | string | Yes | Unique session identifier for tracking and auditing purposes |
| `userId` | integer or null | Yes | User identifier associated with the hardening request; can be null for anonymous requests |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp of the request |
| `hardeningOptions` | object | Yes | Map of hardening categories to arrays of specific hardening options to apply |
| `hardeningOptions.rbac` | array of strings | Conditional | RBAC hardening options (e.g., "enable-strict-policies", "service-account-isolation") |
| `hardeningOptions.network` | array of strings | Conditional | Network policy options (e.g., "deny-all-ingress", "enable-network-policies") |
| `hardeningOptions.pod-security` | array of strings | Conditional | Pod security options (e.g., "restrict-privileged-containers", "enforce-read-only-filesystem") |
| `hardeningOptions.audit` | array of strings | Conditional | Audit logging options (e.g., "enable-audit-logging", "log-authentication-events") |
#### Response
**Success (200):**
Returns a JSON object containing:
- `status`: Operation status indicator
- `sessionId`: Echo of the input session ID
- `timestamp`: Response timestamp
- `hardeningConfigurations`: Object with generated Kubernetes manifests and configurations organized by category
- `recommendations`: Array of additional security recommendations and best practices
**Validation Error (422):**
Returns an `HTTPValidationError` object with:
- `detail`: Array of validation errors, each containing:
- `loc`: Array indicating the location of the error in the request
- `msg`: Human-readable error message
- `type`: Error classification
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/kubernetes
- **API Docs:** https://api.mkkpro.com:8126/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Kubernetes Hardening Tool",
"version": "1.0"
},
"paths": {
"/api/hardening/generate": {
"post": {
"summary": "Generate",
"operationId": "generate_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Request"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"Request": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"userId",
"timestamp"
],
"title": "Request"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional Windows Security Configuration Generator for automated hardening policy creation and deployment.
---
name: Windows Security Hardening Tool
description: Professional Windows Security Configuration Generator for automated hardening policy creation and deployment.
---
# Overview
The Windows Security Hardening Tool is a professional-grade API service designed to automate the generation of Windows security hardening configuration files. It enables security teams, system administrators, and compliance professionals to rapidly create standardized, security-focused Windows configurations tailored to specific organizational requirements.
This tool leverages industry best practices and security frameworks to generate hardening policies that address common Windows vulnerabilities, enforce security baselines, and support compliance requirements. Key capabilities include dynamic configuration generation based on selected hardening options, retrieval of available hardening parameters, and session-based request tracking for audit purposes.
The Windows Security Hardening Tool is ideal for organizations implementing security baselines, preparing systems for production deployment, managing compliance frameworks (CIS, NIST, DoD STIGs), and automating security policy distribution across Windows environments.
## Usage
### Generate Hardening Configuration
Create a hardening configuration by specifying desired security options and session details.
**Request:**
```json
{
"sessionId": "sess-2024-001-hardening",
"userId": 12345,
"timestamp": "2024-01-15T14:30:00Z",
"hardeningOptions": {
"firewall": [
"enable_inbound_rules",
"block_legacy_protocols"
],
"services": [
"disable_unnecessary_services",
"restrict_remote_access"
],
"authentication": [
"enforce_strong_passwords",
"enable_mfa"
],
"audit": [
"enable_event_logging",
"monitor_privileged_access"
]
}
}
```
**Response:**
```json
{
"status": "success",
"configId": "cfg-2024-001-hw7k2x",
"timestamp": "2024-01-15T14:30:05Z",
"hardeningProfile": {
"firewall": {
"inbound_rules": "enabled",
"legacy_protocols": "blocked",
"status": "configured"
},
"services": {
"unnecessary_services": "disabled",
"remote_access": "restricted",
"status": "configured"
},
"authentication": {
"password_policy": "strong_enforcement",
"mfa": "enabled",
"status": "configured"
},
"audit": {
"event_logging": "enabled",
"privileged_access_monitoring": "active",
"status": "configured"
}
},
"downloadUrl": "https://api.mkkpro.com/hardening/download/cfg-2024-001-hw7k2x",
"expiresIn": 86400
}
```
## Endpoints
### GET /
**Description:** Health check endpoint to verify service availability.
**Parameters:** None
**Response:**
- **200 OK**: Service is healthy and operational.
---
### POST /api/hardening/generate
**Description:** Generate Windows security hardening configuration files based on specified hardening options.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `sessionId` | string | Yes | Unique session identifier for request tracking and audit purposes. |
| `userId` | integer \| null | No | Optional user identifier for multi-tenant environments and access control. |
| `timestamp` | string | Yes | ISO 8601 formatted timestamp of the request (e.g., `2024-01-15T14:30:00Z`). |
| `hardeningOptions` | object | Yes | Dictionary of hardening categories, each containing an array of specific hardening options to apply. |
**Request Body Schema:**
```
hardeningOptions: { [category: string]: string[] }
sessionId: string (required)
userId: integer | null (optional)
timestamp: string (required)
```
**Response:**
- **200 OK**: Configuration generated successfully. Returns configuration metadata, applied settings, and download URL.
- **422 Unprocessable Entity**: Validation error on request body. Returns validation error details.
---
### GET /api/hardening/options
**Description:** Retrieve all available hardening options, categories, and their descriptions for use in configuration generation.
**Parameters:** None
**Response:**
- **200 OK**: Complete list of available hardening categories and options, including descriptions and compatibility information.
**Response Structure Example:**
```json
{
"categories": [
{
"name": "firewall",
"description": "Windows Firewall and network security settings",
"options": [
"enable_inbound_rules",
"block_legacy_protocols",
"enforce_egress_filtering"
]
},
{
"name": "services",
"description": "System services configuration and management",
"options": [
"disable_unnecessary_services",
"restrict_remote_access",
"harden_critical_services"
]
},
{
"name": "authentication",
"description": "User authentication and access control",
"options": [
"enforce_strong_passwords",
"enable_mfa",
"restrict_local_accounts"
]
},
{
"name": "audit",
"description": "Event logging and audit trail configuration",
"options": [
"enable_event_logging",
"monitor_privileged_access",
"track_configuration_changes"
]
}
]
}
```
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/hardening/windows
- **API Docs:** https://api.mkkpro.com:8125/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Windows Security Hardening Tool",
"description": "Professional Windows Security Configuration Generator",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/hardening/generate": {
"post": {
"summary": "Generate Hardening Config",
"description": "Generate Windows security hardening configuration files",
"operationId": "generate_hardening_config_api_hardening_generate_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HardeningRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/hardening/options": {
"get": {
"summary": "Get Hardening Options",
"description": "Get all available hardening options",
"operationId": "get_hardening_options_api_hardening_options_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"HardeningRequest": {
"properties": {
"hardeningOptions": {
"additionalProperties": {
"items": {
"type": "string"
},
"type": "array"
},
"type": "object",
"title": "Hardeningoptions"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"hardeningOptions",
"sessionId",
"timestamp"
],
"title": "HardeningRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Comprehensive cybersecurity technology stack recommendation platform that generates personalized security tool recommendations based on organizational assess...
---
name: Security Stack Builder
description: Comprehensive cybersecurity technology stack recommendation platform that generates personalized security tool recommendations based on organizational assessment data.
---
# Overview
Security Stack Builder is a comprehensive API platform designed to generate personalized cybersecurity technology stack recommendations tailored to your organization's unique needs. By analyzing organizational size, industry vertical, budget constraints, security maturity level, deployment model, cloud provider, compliance requirements, and security priorities, the platform delivers curated recommendations for security tools and technologies that align with your risk profile and strategic objectives.
The platform serves security architects, CISO offices, enterprise security teams, and organizations undergoing digital transformation who need data-driven guidance on building effective security stacks. It eliminates guesswork by providing recommendations based on industry best practices, regulatory requirements, and organizational context.
Ideal users include security leaders evaluating tool portfolios, compliance officers building frameworks around regulatory mandates, cloud architects designing security for cloud migrations, and IT teams implementing comprehensive security programs across hybrid and multi-cloud environments.
## Usage
**Example Request:**
```json
{
"assessmentData": {
"orgSize": "Enterprise",
"industry": "Financial Services",
"budget": "High",
"maturity": "Intermediate",
"deployment": "Hybrid",
"cloudProvider": "AWS",
"compliance": ["PCI-DSS", "SOC2"],
"priorities": ["Data Protection", "Threat Detection", "Identity Management"],
"sessionId": "sess_abc123xyz789",
"timestamp": "2024-01-15T10:30:00Z"
},
"sessionId": "sess_abc123xyz789",
"userId": 4521,
"timestamp": "2024-01-15T10:30:00Z"
}
```
**Example Response:**
```json
{
"stackId": "stack_f7e3d9c2a1b8",
"recommendations": [
{
"category": "Identity and Access Management",
"tools": [
{
"name": "Okta",
"tier": "Primary",
"rationale": "Enterprise-grade IAM with strong PCI-DSS compliance support"
},
{
"name": "HashiCorp Vault",
"tier": "Secondary",
"rationale": "Secrets management for hybrid deployments"
}
]
},
{
"category": "Threat Detection",
"tools": [
{
"name": "CrowdStrike Falcon",
"tier": "Primary",
"rationale": "Cloud-native EDR platform with strong AWS integration"
}
]
},
{
"category": "Data Protection",
"tools": [
{
"name": "Varonis",
"tier": "Primary",
"rationale": "Data classification and DLP aligned with financial services requirements"
}
]
}
],
"complianceMapping": {
"PCI-DSS": ["Okta", "CrowdStrike Falcon"],
"SOC2": ["Okta", "HashiCorp Vault", "Varonis"]
},
"estimatedAnnualCost": "$450000-$750000",
"implementationPhases": [
"Phase 1: Identity Foundation (Months 1-3)",
"Phase 2: Threat Detection Layer (Months 4-6)",
"Phase 3: Data Protection Deployment (Months 7-9)"
],
"sessionId": "sess_abc123xyz789",
"generatedAt": "2024-01-15T10:31:22Z"
}
```
## Endpoints
### GET /
**Description:** Health check endpoint to verify API availability.
**Parameters:** None
**Response:** Returns a 200 status with service health information.
---
### POST /api/security/stack
**Description:** Generate personalized security stack recommendations based on organizational assessment data.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| assessmentData | object | ✓ | Assessment data object containing organizational context |
| assessmentData.orgSize | string | ✓ | Organization size (e.g., "SMB", "Mid-Market", "Enterprise") |
| assessmentData.industry | string | ✓ | Industry vertical (e.g., "Financial Services", "Healthcare", "Technology") |
| assessmentData.budget | string | ✓ | Budget level (e.g., "Low", "Medium", "High") |
| assessmentData.maturity | string | ✓ | Security maturity level (e.g., "Beginner", "Intermediate", "Advanced") |
| assessmentData.deployment | string | ✓ | Deployment model (e.g., "On-Premises", "Cloud", "Hybrid") |
| assessmentData.cloudProvider | string | Optional | Cloud provider if applicable (e.g., "AWS", "Azure", "GCP") |
| assessmentData.compliance | array | Optional | List of compliance requirements (e.g., ["PCI-DSS", "HIPAA", "SOC2"]) |
| assessmentData.priorities | array | Optional | List of security priorities (e.g., ["Data Protection", "Threat Detection"]) |
| assessmentData.sessionId | string | ✓ | Unique session identifier |
| assessmentData.timestamp | string | ✓ | ISO 8601 timestamp of assessment |
| sessionId | string | ✓ | Request session identifier |
| userId | integer | Optional | User identifier for tracking and analytics |
| timestamp | string | ✓ | ISO 8601 timestamp of request |
**Response:** Returns 200 with security stack recommendations including tool suggestions, compliance mapping, cost estimates, and implementation phases. Returns 422 for validation errors.
---
### GET /api/security/categories
**Description:** Retrieve all available security categories for which recommendations can be provided.
**Parameters:** None
**Response:** Returns 200 with a list of security categories such as "Identity and Access Management", "Threat Detection", "Data Protection", "Cloud Security", "Compliance and Governance", etc.
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- Kong Route: https://api.mkkpro.com/security/security-stack-builder
- API Docs: https://api.mkkpro.com:8122/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Security Stack Builder",
"description": "Comprehensive Cybersecurity Technology Stack Recommendation Platform",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/security/stack": {
"post": {
"summary": "Generate Security Stack",
"description": "Generate personalized security stack recommendations",
"operationId": "generate_security_stack_api_security_stack_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/StackRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/security/categories": {
"get": {
"summary": "Get Security Categories",
"description": "Get all available security categories",
"operationId": "get_security_categories_api_security_categories_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"AssessmentData": {
"properties": {
"orgSize": {
"type": "string",
"title": "Orgsize"
},
"industry": {
"type": "string",
"title": "Industry"
},
"budget": {
"type": "string",
"title": "Budget"
},
"maturity": {
"type": "string",
"title": "Maturity"
},
"deployment": {
"type": "string",
"title": "Deployment"
},
"cloudProvider": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"title": "Cloudprovider",
"default": ""
},
"compliance": {
"items": {
"type": "string"
},
"type": "array",
"title": "Compliance",
"default": []
},
"priorities": {
"items": {
"type": "string"
},
"type": "array",
"title": "Priorities",
"default": []
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"orgSize",
"industry",
"budget",
"maturity",
"deployment",
"sessionId",
"timestamp"
],
"title": "AssessmentData"
},
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"StackRequest": {
"properties": {
"assessmentData": {
"$ref": "#/components/schemas/AssessmentData"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"assessmentData",
"sessionId",
"timestamp"
],
"title": "StackRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional multi-dimensional security maturity evaluation platform that assesses organizational security across eight critical domains.
---
name: Security Posture Maturity Assessment
description: Professional multi-dimensional security maturity evaluation platform that assesses organizational security across eight critical domains.
---
# Overview
The Security Posture Maturity Assessment API provides a comprehensive, professional-grade evaluation framework for measuring organizational security maturity across multiple dimensions. This platform enables security teams, compliance officers, and enterprise architects to systematically assess their security posture against industry-standard maturity levels and identify gaps in critical security domains.
The tool evaluates eight essential security domains: Network Security, Cloud Security, Endpoint Security, Identity & Access Management, Data Security, Application Security, Physical Security, and Governance & Compliance. Each domain is rated on a 1-5 maturity scale, providing granular visibility into organizational security strengths and weaknesses.
This API is ideal for enterprises conducting security audits, preparing for compliance assessments, benchmarking against industry standards, and developing strategic security improvement roadmaps. Organizations can track maturity progression over time and generate actionable intelligence for board-level and operational security governance.
# Usage
## Sample Request
```json
{
"assessmentData": {
"network_security": 3,
"cloud_security": 2,
"endpoint_security": 4,
"identity_access": 3,
"data_security": 2,
"application_security": 3,
"physical_security": 4,
"governance_compliance": 2
},
"sessionId": "sess_20240115_acme_corp",
"userId": 12847,
"timestamp": "2024-01-15T14:30:00Z"
}
```
## Sample Response
```json
{
"assessmentId": "assess_67890abcdef",
"organizationScore": 2.875,
"maturityLevel": "Managed",
"timestamp": "2024-01-15T14:30:15Z",
"domainScores": {
"network_security": {
"score": 3,
"maturityLevel": "Defined",
"status": "Moderate"
},
"cloud_security": {
"score": 2,
"maturityLevel": "Repeatable",
"status": "Below Target"
},
"endpoint_security": {
"score": 4,
"maturityLevel": "Managed",
"status": "Strong"
},
"identity_access": {
"score": 3,
"maturityLevel": "Defined",
"status": "Moderate"
},
"data_security": {
"score": 2,
"maturityLevel": "Repeatable",
"status": "Below Target"
},
"application_security": {
"score": 3,
"maturityLevel": "Defined",
"status": "Moderate"
},
"physical_security": {
"score": 4,
"maturityLevel": "Managed",
"status": "Strong"
},
"governance_compliance": {
"score": 2,
"maturityLevel": "Repeatable",
"status": "Below Target"
}
},
"recommendations": [
{
"domain": "cloud_security",
"priority": "High",
"action": "Implement cloud security baseline controls and automation"
},
{
"domain": "data_security",
"priority": "High",
"action": "Establish data classification and encryption standards"
}
]
}
```
# Endpoints
## GET /
**Health Check Endpoint**
Verifies API service availability and health status.
**Method:** GET
**Path:** `/`
**Parameters:** None
**Response:**
- **Status 200:** Service operational (JSON object)
---
## POST /api/maturity/assess
**Generate Maturity Assessment**
Generates a comprehensive security maturity assessment based on provided domain scores and organizational context.
**Method:** POST
**Path:** `/api/maturity/assess`
**Request Body Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `assessmentData` | AssessmentData object | Yes | Container for all eight security domain scores |
| `assessmentData.network_security` | Integer (1-5) | Yes | Network Security maturity score |
| `assessmentData.cloud_security` | Integer (1-5) | Yes | Cloud Security maturity score |
| `assessmentData.endpoint_security` | Integer (1-5) | Yes | Endpoint Security maturity score |
| `assessmentData.identity_access` | Integer (1-5) | Yes | Identity & Access Management maturity score |
| `assessmentData.data_security` | Integer (1-5) | Yes | Data Security maturity score |
| `assessmentData.application_security` | Integer (1-5) | Yes | Application Security maturity score |
| `assessmentData.physical_security` | Integer (1-5) | Yes | Physical Security maturity score |
| `assessmentData.governance_compliance` | Integer (1-5) | Yes | Governance & Compliance maturity score |
| `sessionId` | String | Yes | Unique session identifier for tracking |
| `userId` | Integer | No | User identifier (optional) |
| `timestamp` | String | Yes | ISO 8601 formatted timestamp of assessment |
**Response:**
- **Status 200:** Assessment generated successfully (JSON object with domain scores, overall maturity level, and recommendations)
- **Status 422:** Validation error in request body (missing required fields or invalid score ranges)
---
## GET /api/maturity/domains
**Get Security Domains**
Retrieves the complete list of available security domains and their definitions.
**Method:** GET
**Path:** `/api/maturity/domains`
**Parameters:** None
**Response:**
- **Status 200:** JSON array of security domain definitions including domain name, description, and assessment criteria
---
## GET /api/maturity/levels
**Get Maturity Levels**
Retrieves definitions and characteristics of each maturity level used in assessments.
**Method:** GET
**Path:** `/api/maturity/levels`
**Parameters:** None
**Response:**
- **Status 200:** JSON object containing maturity level definitions (e.g., Initial, Repeatable, Defined, Managed, Optimized) with descriptions and requirements for each level
# Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
# About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
# References
- **Kong Route:** https://api.mkkpro.com/security/security-posture-maturity
- **API Docs:** https://api.mkkpro.com:8121/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Security Posture Maturity Assessment",
"description": "Professional Multi-Dimensional Security Maturity Evaluation Platform",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/maturity/assess": {
"post": {
"summary": "Generate Maturity Assessment",
"description": "Generate comprehensive security maturity assessment",
"operationId": "generate_maturity_assessment_api_maturity_assess_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/MaturityRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/maturity/domains": {
"get": {
"summary": "Get Security Domains",
"description": "Get available security domains",
"operationId": "get_security_domains_api_maturity_domains_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/maturity/levels": {
"get": {
"summary": "Get Maturity Levels",
"description": "Get maturity level definitions",
"operationId": "get_maturity_levels_api_maturity_levels_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"AssessmentData": {
"properties": {
"network_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Network Security"
},
"cloud_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Cloud Security"
},
"endpoint_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Endpoint Security"
},
"identity_access": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Identity Access"
},
"data_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Data Security"
},
"application_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Application Security"
},
"physical_security": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Physical Security"
},
"governance_compliance": {
"type": "integer",
"maximum": 5.0,
"minimum": 1.0,
"title": "Governance Compliance"
}
},
"type": "object",
"required": [
"network_security",
"cloud_security",
"endpoint_security",
"identity_access",
"data_security",
"application_security",
"physical_security",
"governance_compliance"
],
"title": "AssessmentData"
},
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"MaturityRequest": {
"properties": {
"assessmentData": {
"$ref": "#/components/schemas/AssessmentData"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"assessmentData",
"sessionId",
"timestamp"
],
"title": "MaturityRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional security testing and vulnerability assessment tool for simulating cyber attacks and generating comprehensive security reports.
---
name: Cyber Attack Simulation Platform
description: Professional security testing and vulnerability assessment tool for simulating cyber attacks and generating comprehensive security reports.
---
# Overview
The Cyber Attack Simulation Platform is a professional-grade security testing solution designed to help organizations identify vulnerabilities and assess their defensive posture through controlled cyber attack simulations. Built for security teams, penetration testers, and risk management professionals, this platform enables realistic attack scenario modeling without exposing production systems to actual threats.
The platform supports multiple attack types with configurable intensity levels, allowing security professionals to simulate various threat vectors and measure organizational resilience. It integrates a comprehensive vulnerability database and provides detailed security reports that inform remediation strategies and security improvements.
Ideal users include enterprise security teams, managed security service providers (MSSPs), penetration testing firms, and compliance-focused organizations that need evidence-based security assessments to validate defensive controls and meet regulatory requirements.
## Usage
### Example Request
Run a simulated phishing and SQL injection attack against a test environment with medium intensity:
```json
{
"simulationData": {
"target": {
"hostname": "test-app.internal.company.com",
"port": 443,
"protocol": "https",
"environment": "staging"
},
"attackTypes": [
"phishing",
"sql_injection"
],
"intensity": 5,
"sessionId": "sess-a1b2c3d4e5f6g7h8",
"timestamp": "2025-01-15T14:30:00Z"
},
"sessionId": "sess-a1b2c3d4e5f6g7h8",
"userId": 12847,
"timestamp": "2025-01-15T14:30:00Z"
}
```
### Example Response
```json
{
"success": true,
"simulationId": "sim-9x8y7z6w5v4u3t2s",
"status": "completed",
"duration_seconds": 287,
"timestamp": "2025-01-15T14:35:27Z",
"findings": {
"critical": 2,
"high": 5,
"medium": 12,
"low": 18
},
"vulnerabilities_discovered": [
{
"id": "CVE-2024-1234",
"type": "sql_injection",
"severity": "critical",
"endpoint": "/api/users/search",
"parameter": "q",
"remediation": "Use parameterized queries and input validation"
},
{
"id": "vuln-auth-001",
"type": "weak_authentication",
"severity": "high",
"description": "Password policy does not enforce complexity requirements",
"remediation": "Implement NIST SP 800-63B compliant password policies"
}
],
"attack_summary": {
"phishing": {
"attempts": 50,
"successful": 8,
"success_rate": 0.16
},
"sql_injection": {
"attempts": 120,
"successful": 2,
"success_rate": 0.017
}
},
"security_score": 62,
"recommendation": "Address critical vulnerabilities immediately. Implement security awareness training for phishing resistance."
}
```
## Endpoints
### GET /
**Health Check**
Verifies that the Cyber Attack Simulation Platform API is operational.
**Parameters:** None
**Response:**
- Status 200: Service health confirmation with operational status
---
### POST /api/cyber/simulation
**Run Cyber Simulation**
Initiates and executes a cyber attack simulation against a specified target with configured attack types and intensity level. Generates a comprehensive security report with vulnerability findings and remediation guidance.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| simulationData | object | Yes | Container for simulation configuration including target details, attack types, and intensity |
| simulationData.target | object | No | Target system details (hostname, port, protocol, environment) |
| simulationData.attackTypes | array[string] | No | List of attack types to simulate (e.g., phishing, sql_injection, ddos, brute_force) |
| simulationData.intensity | integer | No | Intensity level of simulation from 1-10 (default: 3). Higher values increase attack aggressiveness |
| simulationData.sessionId | string | Yes | Unique identifier for this simulation session |
| simulationData.timestamp | string | Yes | ISO 8601 timestamp when simulation was initiated |
| sessionId | string | Yes | Top-level session identifier for request tracking |
| userId | integer or null | No | ID of the user initiating the simulation (optional) |
| timestamp | string | Yes | ISO 8601 timestamp of request submission |
**Response:**
- Status 200: Simulation execution results including vulnerabilities discovered, attack summary, security score, and remediation recommendations
- Status 422: Validation error if required parameters are missing or malformed
---
### GET /api/cyber/vulnerabilities
**Get Vulnerability Database**
Retrieves comprehensive vulnerability database information including known CVEs, vulnerability classifications, and threat intelligence data used for simulation and assessment.
**Parameters:** None
**Response:**
- Status 200: Vulnerability database metadata, counts by severity, CVE listings, and last update timestamp
---
### GET /api/cyber/attack-types
**Get Attack Types**
Retrieves the complete list of available attack types supported by the simulation platform, including descriptions and recommended intensity ranges for each attack vector.
**Parameters:** None
**Response:**
- Status 200: Array of available attack types with descriptions, difficulty levels, and use cases (e.g., phishing, sql_injection, ddos, brute_force, cross_site_scripting, privilege_escalation)
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/security/cyber-attack-simulation
- **API Documentation:** https://api.mkkpro.com:8120/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Cyber Attack Simulation Platform",
"description": "Professional Security Testing and Vulnerability Assessment",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/cyber/simulation": {
"post": {
"summary": "Run Cyber Simulation",
"description": "Run cyber attack simulation and generate security report",
"operationId": "run_cyber_simulation_api_cyber_simulation_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/SimulationRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/cyber/vulnerabilities": {
"get": {
"summary": "Get Vulnerability Db",
"description": "Get vulnerability database information",
"operationId": "get_vulnerability_db_api_cyber_vulnerabilities_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/cyber/attack-types": {
"get": {
"summary": "Get Attack Types",
"description": "Get available attack types for simulation",
"operationId": "get_attack_types_api_cyber_attack_types_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"SimulationData": {
"properties": {
"target": {
"type": "object",
"title": "Target",
"default": {}
},
"attackTypes": {
"items": {
"type": "string"
},
"type": "array",
"title": "Attacktypes",
"default": []
},
"intensity": {
"type": "integer",
"title": "Intensity",
"default": 3
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"sessionId",
"timestamp"
],
"title": "SimulationData"
},
"SimulationRequest": {
"properties": {
"simulationData": {
"$ref": "#/components/schemas/SimulationData"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"simulationData",
"sessionId",
"timestamp"
],
"title": "SimulationRequest"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Professional network security assessment and gap analysis platform generating comprehensive audit reports across security domains and compliance frameworks.
---
name: Network Security Audit Platform
description: Professional network security assessment and gap analysis platform generating comprehensive audit reports across security domains and compliance frameworks.
---
# Overview
The Network Security Audit Platform is a comprehensive security assessment tool designed to evaluate organizational network infrastructure against industry standards and best practices. It provides detailed analysis across 12 critical security domains, including network architecture, segmentation, firewall configuration, intrusion detection, vulnerability management, access controls, encryption, patch management, and vendor security.
This platform enables security teams, compliance officers, and network administrators to conduct professional security audits, identify gaps in their security posture, and generate compliance reports aligned with major frameworks. The tool systematically evaluates each security domain through checkpoint-based assessments and detailed notes, providing actionable insights for remediation.
Ideal users include enterprise security teams, managed security service providers (MSSPs), compliance auditors, and organizations preparing for security certifications or regulatory assessments. The platform supports multi-user workflows with session tracking and user attribution for audit accountability.
## Usage
**Example Request:**
```json
{
"sessionId": "audit-2024-001",
"userId": 42,
"timestamp": "2024-01-15T10:30:00Z",
"assessmentData": {
"architecture": {
"checkpoints": [true, true, false],
"notes": "Network design reviewed. Missing DMZ segmentation for web tier."
},
"segmentation": {
"checkpoints": [true, false],
"notes": "VLAN segregation partially implemented. Production and development not isolated."
},
"firewall": {
"checkpoints": [true, true, true],
"notes": "Perimeter firewall properly configured with stateful inspection enabled."
},
"ids_ips": {
"checkpoints": [false],
"notes": "IDS/IPS not currently deployed. Recommend immediate implementation."
},
"vulnerabilities": {
"checkpoints": [true, false, true],
"notes": "Vulnerability scanning active but remediation SLA not documented."
},
"access_controls": {
"checkpoints": [true, true],
"notes": "Role-based access control implemented. MFA enabled for administrative accounts."
},
"access_logs": {
"checkpoints": [true, false],
"notes": "Logs collected but retention policy only 90 days. Recommend 1-year minimum."
},
"encryption": {
"checkpoints": [true, true, false],
"notes": "TLS in-transit encryption enabled. Data-at-rest encryption partial."
},
"remote_access": {
"checkpoints": [true],
"notes": "VPN implemented with certificate-based authentication."
},
"patch_management": {
"checkpoints": [true, false],
"notes": "Patch policy documented but deployment automation not fully implemented."
},
"backup_recovery": {
"checkpoints": [true, true],
"notes": "Daily incremental backups with monthly full backups. RTO/RPO defined."
},
"vendor_security": {
"checkpoints": [false, true],
"notes": "Vendor assessments incomplete. Begin third-party risk program."
}
}
}
```
**Example Response:**
```json
{
"auditId": "audit-20240115-001",
"sessionId": "audit-2024-001",
"userId": 42,
"timestamp": "2024-01-15T10:30:00Z",
"completionTime": "2024-01-15T10:35:22Z",
"overallScore": 72,
"domainScores": {
"architecture": 67,
"segmentation": 50,
"firewall": 100,
"ids_ips": 0,
"vulnerabilities": 67,
"access_controls": 100,
"access_logs": 50,
"encryption": 67,
"remote_access": 100,
"patch_management": 50,
"backup_recovery": 100,
"vendor_security": 50
},
"summary": "Network security posture is adequate but requires improvements in threat detection, data protection, and vendor risk management.",
"criticalFindings": [
"IDS/IPS deployment is missing - critical gap in threat detection capability",
"Data-at-rest encryption incomplete - sensitive information may be exposed",
"Vendor security assessment program not formalized"
],
"recommendations": [
"Deploy IDS/IPS solution within 30 days",
"Complete data-at-rest encryption for all sensitive systems within 90 days",
"Establish vendor risk assessment and SLA framework within 60 days",
"Extend access log retention to minimum 1 year",
"Automate patch deployment processes"
],
"complianceMapping": {
"NIST-CSF": 0.74,
"CIS": 0.69,
"ISO27001": 0.71
}
}
```
## Endpoints
### `GET /`
**Health Check Endpoint**
Verifies API availability and readiness.
- **Method:** `GET`
- **Path:** `/`
- **Description:** Returns health status of the Network Security Audit Platform
- **Parameters:** None
- **Response:** JSON object confirming API operational status (200 OK)
---
### `POST /api/security/audit`
**Generate Security Audit**
Creates a comprehensive network security audit report based on assessment data provided.
- **Method:** `POST`
- **Path:** `/api/security/audit`
- **Description:** Processes assessment data across 12 security domains and generates detailed audit report with scores, findings, and compliance mappings
**Request Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `assessmentData` | `AssessmentData` | Yes | Assessment data containing security domain evaluations |
| `sessionId` | `string` | Yes | Unique session identifier for audit tracking |
| `userId` | `integer` | No | User ID attributing the audit request |
| `timestamp` | `string` | Yes | ISO 8601 timestamp of audit initiation |
**AssessmentData Structure:**
Contains 12 security domains, each with:
- `checkpoints` (array of booleans): Pass/fail assessment for each checkpoint
- `notes` (string): Detailed observations and findings
**Domains:**
- `architecture` - Network architecture and design
- `segmentation` - Network segmentation and isolation
- `firewall` - Firewall configuration and rules
- `ids_ips` - Intrusion Detection/Prevention Systems
- `vulnerabilities` - Vulnerability management processes
- `access_controls` - Authentication and authorization
- `access_logs` - Access logging and audit trails
- `encryption` - Data protection in transit and at rest
- `remote_access` - Remote access security controls
- `patch_management` - Software patch deployment
- `backup_recovery` - Backup and disaster recovery
- `vendor_security` - Third-party and vendor management
**Response:** JSON audit report with scores, findings, recommendations, and compliance framework mappings (200 OK) or validation error details (422 Unprocessable Entity)
---
### `GET /api/security/domains`
**Get Security Domains**
Retrieves definitions and documentation for all available security assessment domains.
- **Method:** `GET`
- **Path:** `/api/security/domains`
- **Description:** Lists all 12 security domains supported by the platform with their definitions, assessment criteria, and best practice references
- **Parameters:** None
- **Response:** JSON array of domain definitions with checkpoint descriptions and compliance mappings (200 OK)
---
### `GET /api/security/frameworks`
**Get Compliance Frameworks**
Retrieves list of supported compliance frameworks and their assessment criteria.
- **Method:** `GET`
- **Path:** `/api/security/frameworks`
- **Description:** Returns available compliance frameworks (NIST CSF, CIS, ISO 27001, etc.) with scoring methodologies and requirement mappings
- **Parameters:** None
- **Response:** JSON array of framework definitions with requirement details and scoring weights (200 OK)
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/security/network-security-audit
- **API Docs:** https://api.mkkpro.com:8119/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Network Security Audit Platform",
"description": "Professional Network Security Assessment & Gap Analysis Platform",
"version": "1.0.0"
},
"paths": {
"/": {
"get": {
"summary": "Root",
"description": "Health check endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/security/audit": {
"post": {
"summary": "Generate Security Audit",
"description": "Generate comprehensive network security audit report",
"operationId": "generate_security_audit_api_security_audit_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/AuditRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/security/domains": {
"get": {
"summary": "Get Security Domains",
"description": "Get available security domains and their definitions",
"operationId": "get_security_domains_api_security_domains_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/api/security/frameworks": {
"get": {
"summary": "Get Compliance Frameworks",
"description": "Get available compliance frameworks",
"operationId": "get_compliance_frameworks_api_security_frameworks_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"AssessmentData": {
"properties": {
"architecture": {
"$ref": "#/components/schemas/DomainData"
},
"segmentation": {
"$ref": "#/components/schemas/DomainData"
},
"firewall": {
"$ref": "#/components/schemas/DomainData"
},
"ids_ips": {
"$ref": "#/components/schemas/DomainData"
},
"vulnerabilities": {
"$ref": "#/components/schemas/DomainData"
},
"access_controls": {
"$ref": "#/components/schemas/DomainData"
},
"access_logs": {
"$ref": "#/components/schemas/DomainData"
},
"encryption": {
"$ref": "#/components/schemas/DomainData"
},
"remote_access": {
"$ref": "#/components/schemas/DomainData"
},
"patch_management": {
"$ref": "#/components/schemas/DomainData"
},
"backup_recovery": {
"$ref": "#/components/schemas/DomainData"
},
"vendor_security": {
"$ref": "#/components/schemas/DomainData"
}
},
"type": "object",
"required": [
"architecture",
"segmentation",
"firewall",
"ids_ips",
"vulnerabilities",
"access_controls",
"access_logs",
"encryption",
"remote_access",
"patch_management",
"backup_recovery",
"vendor_security"
],
"title": "AssessmentData"
},
"AuditRequest": {
"properties": {
"assessmentData": {
"$ref": "#/components/schemas/AssessmentData"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"assessmentData",
"sessionId",
"timestamp"
],
"title": "AuditRequest"
},
"DomainData": {
"properties": {
"checkpoints": {
"items": {
"type": "boolean"
},
"type": "array",
"title": "Checkpoints",
"default": []
},
"notes": {
"type": "string",
"title": "Notes",
"default": ""
}
},
"type": "object",
"title": "DomainData"
},
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}Generates customized incident response playbooks tailored to organizational assessment data and security requirements.
---
name: Incident Response Playbook Generator API
description: Generates customized incident response playbooks tailored to organizational assessment data and security requirements.
---
# Overview
The Incident Response Playbook Generator API automates the creation of comprehensive, organization-specific incident response playbooks. Security teams and incident response managers use this tool to rapidly produce formal documentation that aligns with their organizational structure, compliance requirements, and threat landscape.
This API transforms assessment data—including organizational context, existing security controls, and risk profiles—into a fully structured playbook containing executive summaries, response phases, team roles, communication templates, escalation procedures, legal considerations, and emergency contact lists. Rather than starting from scratch with generic templates, teams receive customized playbooks that reflect their unique operational environment.
Ideal users include security operations centers (SOCs), incident response teams, compliance officers, security architects, and organizations preparing for security audits or regulatory assessments.
## Usage
**Sample Request:**
```json
{
"assessmentData": {
"organization_name": "TechCorp Inc.",
"industry": "Financial Services",
"employee_count": 2500,
"critical_systems": ["Payment Processing", "Customer Database", "Internal Email"],
"compliance_frameworks": ["PCI-DSS", "SOC 2", "GDPR"],
"current_ir_maturity": "Intermediate",
"primary_threats": ["Ransomware", "Data Exfiltration", "Insider Threats"]
},
"sessionId": "sess_abc123def456",
"userId": 42,
"timestamp": "2024-01-15T10:30:00Z"
}
```
**Sample Response:**
```json
{
"playbook_title": "TechCorp Inc. Incident Response Playbook 2024",
"organization_name": "TechCorp Inc.",
"executive_summary": "This playbook establishes a comprehensive incident response framework for TechCorp Inc., addressing ransomware, data exfiltration, and insider threats within financial services operations. The plan aligns with PCI-DSS, SOC 2, and GDPR requirements and is tailored for an intermediate maturity security posture.",
"phases": [
{
"phase_name": "Detection & Analysis",
"duration": "0-4 hours",
"objectives": ["Confirm incident validity", "Classify severity and type", "Preserve evidence"],
"key_actions": ["Enable enhanced logging", "Isolate affected systems", "Notify IR team"]
},
{
"phase_name": "Containment",
"duration": "4-24 hours",
"objectives": ["Stop active attack", "Prevent spread", "Preserve forensic data"],
"key_actions": ["Segment network", "Reset credentials", "Deploy patches"]
},
{
"phase_name": "Eradication",
"duration": "1-7 days",
"objectives": ["Remove attacker presence", "Close vulnerabilities", "Validate remediation"],
"key_actions": ["Rebuild systems", "Apply security updates", "Conduct forensics"]
},
{
"phase_name": "Recovery",
"duration": "1-14 days",
"objectives": ["Restore normal operations", "Verify system integrity", "Restore data"],
"key_actions": ["Bring systems online", "Monitor for recompromise", "Validate backups"]
},
{
"phase_name": "Post-Incident",
"duration": "Ongoing",
"objectives": ["Document lessons learned", "Improve processes", "Update security controls"],
"key_actions": ["Conduct review meeting", "Update playbook", "Implement improvements"]
}
],
"roles": [
{
"role": "Incident Commander",
"responsibility": "Overall coordination and decision authority",
"reporting_chain": "Chief Information Security Officer"
},
{
"role": "Technical Lead",
"responsibility": "Technical investigation and remediation direction",
"reporting_chain": "Incident Commander"
},
{
"role": "Communications Lead",
"responsibility": "Internal and external stakeholder communication",
"reporting_chain": "Incident Commander"
},
{
"role": "Legal & Compliance",
"responsibility": "Regulatory notification and legal guidance",
"reporting_chain": "Incident Commander"
}
],
"communication_templates": [
{
"template_name": "Internal Alert",
"recipient": "All Staff",
"message": "A potential security incident has been detected and is being investigated. IT support may be slower than normal. Do not open suspicious emails or click unknown links."
},
{
"template_name": "Executive Briefing",
"recipient": "C-Suite, Board",
"message": "At [TIME], a security incident was detected. Current status: [STATUS]. Estimated impact: [IMPACT]. Expected resolution: [TIMELINE]."
},
{
"template_name": "Customer Notification",
"recipient": "Affected Customers",
"message": "We recently identified a security incident that may have affected your data. Here's what happened, what we're doing, and how to protect yourself."
}
],
"escalation_procedures": "Incidents are classified by severity (Low, Medium, High, Critical) based on impact and affected systems. Low incidents are managed by SOC; Medium and High require Incident Commander activation; Critical incidents trigger executive notification within 15 minutes and external communication within 1 hour per GDPR and PCI-DSS requirements.",
"legal_considerations": [
"GDPR: Notify regulators within 72 hours of confirmed data breach involving EU resident personal data",
"PCI-DSS: Notify acquiring bank and card brands of confirmed compromise within 30 days",
"SOC 2: Maintain audit trail and document all investigation steps for Type II audit review",
"Financial Services Compliance: Report material incidents to regulators per industry-specific guidance"
],
"contact_list": [
{
"role": "CISO",
"name": "Sarah Chen",
"phone": "+1-555-0101",
"email": "[email protected]",
"available_24_7": true
},
{
"role": "Legal Counsel",
"name": "James Mitchell",
"phone": "+1-555-0102",
"email": "[email protected]",
"available_24_7": false
},
{
"role": "Forensics Vendor",
"name": "ForensicPro LLC",
"phone": "+1-800-FORENSIC",
"email": "[email protected]",
"available_24_7": true
}
],
"session_id": "sess_abc123def456",
"timestamp": "2024-01-15T10:32:45Z"
}
```
## Endpoints
### POST /api/ir/playbook
**Summary:** Generate Playbook
**Description:** Generate a customized incident response playbook based on assessment data, organizational context, and security requirements.
**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| `assessmentData` | object | Yes | Structured assessment data including organization details, critical systems, compliance frameworks, threat landscape, and current IR maturity level |
| `sessionId` | string | Yes | Unique session identifier for tracking and audit purposes |
| `userId` | integer | No | User ID of the requester for multi-tenant environments and audit logging |
| `timestamp` | string | No | ISO 8601 timestamp indicating when the request was initiated |
**Request Body Schema:** `PlaybookRequest`
**Response (200 - Success):**
Returns a `PlaybookResponse` object containing:
- `playbook_title` (string): Formal title of the generated playbook
- `organization_name` (string): Name of the organization
- `executive_summary` (string): High-level overview of the playbook and organizational context
- `phases` (array of objects): Incident response phases (Detection, Containment, Eradication, Recovery, Post-Incident) with duration, objectives, and key actions
- `roles` (array of objects): Defined incident response team roles, responsibilities, and reporting chains
- `communication_templates` (array of objects): Ready-to-use message templates for internal alerts, executive briefings, and customer notifications
- `escalation_procedures` (string): Procedures for classifying incident severity and escalation paths
- `legal_considerations` (array of strings): Compliance and regulatory obligations applicable to the organization
- `contact_list` (array of objects): Emergency contacts including name, role, phone, email, and 24/7 availability status
- `session_id` (string): Echo of the request session ID
- `timestamp` (string): ISO 8601 timestamp of response generation
**Response (422 - Validation Error):**
Returns `HTTPValidationError` containing an array of `ValidationError` objects with:
- `loc` (array): Location of the error (field path)
- `msg` (string): Error message
- `type` (string): Error type (e.g., "value_error", "type_error")
---
### GET /api/ir/health
**Summary:** Health Check
**Description:** Verify the API service is operational and responsive.
**Parameters:** None
**Response (200 - Success):**
Returns a JSON object indicating service status.
---
### GET /
**Summary:** Root Endpoint
**Description:** Root service endpoint; may return service metadata or welcome information.
**Parameters:** None
**Response (200 - Success):**
Returns a JSON object with service information.
## Pricing
| Plan | Calls/Day | Calls/Month | Price |
|------|-----------|-------------|-------|
| Free | 5 | 50 | Free |
| Developer | 20 | 500 | $39/mo |
| Professional | 200 | 5,000 | $99/mo |
| Enterprise | 100,000 | 1,000,000 | $299/mo |
## About
ToolWeb.in - 200+ security APIs, CISSP & CISM, platforms: Pay-per-run, API Gateway, MCP Server, OpenClaw, RapidAPI, YouTube.
- [toolweb.in](https://toolweb.in)
- [portal.toolweb.in](https://portal.toolweb.in)
- [hub.toolweb.in](https://hub.toolweb.in)
- [toolweb.in/openclaw/](https://toolweb.in/openclaw/)
- [rapidapi.com/user/mkrishna477](https://rapidapi.com/user/mkrishna477)
- [youtube.com/@toolweb-009](https://youtube.com/@toolweb-009)
## References
- **Kong Route:** https://api.mkkpro.com/security/ir-playbook-generator
- **API Docs:** https://api.mkkpro.com:8118/docs
FILE:openapi.json
{
"openapi": "3.1.0",
"info": {
"title": "Incident Response Playbook Generator API",
"version": "0.1.0"
},
"paths": {
"/api/ir/playbook": {
"post": {
"summary": "Generate Playbook",
"description": "Generate customized incident response playbook",
"operationId": "generate_playbook_api_ir_playbook_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PlaybookRequest"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PlaybookResponse"
}
}
}
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
}
}
}
}
},
"/api/ir/health": {
"get": {
"summary": "Health Check",
"description": "Health check endpoint",
"operationId": "health_check_api_ir_health_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
},
"/": {
"get": {
"summary": "Root",
"description": "Root endpoint",
"operationId": "root__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {}
}
}
}
}
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail"
}
},
"type": "object",
"title": "HTTPValidationError"
},
"PlaybookRequest": {
"properties": {
"assessmentData": {
"type": "object",
"title": "Assessmentdata"
},
"sessionId": {
"type": "string",
"title": "Sessionid"
},
"userId": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"title": "Userid"
},
"timestamp": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"title": "Timestamp"
}
},
"type": "object",
"required": [
"assessmentData",
"sessionId"
],
"title": "PlaybookRequest"
},
"PlaybookResponse": {
"properties": {
"playbook_title": {
"type": "string",
"title": "Playbook Title"
},
"organization_name": {
"type": "string",
"title": "Organization Name"
},
"executive_summary": {
"type": "string",
"title": "Executive Summary"
},
"phases": {
"items": {
"type": "object"
},
"type": "array",
"title": "Phases"
},
"roles": {
"items": {
"type": "object"
},
"type": "array",
"title": "Roles"
},
"communication_templates": {
"items": {
"type": "object"
},
"type": "array",
"title": "Communication Templates"
},
"escalation_procedures": {
"type": "string",
"title": "Escalation Procedures"
},
"legal_considerations": {
"items": {
"type": "string"
},
"type": "array",
"title": "Legal Considerations"
},
"contact_list": {
"items": {
"additionalProperties": {
"type": "string"
},
"type": "object"
},
"type": "array",
"title": "Contact List"
},
"session_id": {
"type": "string",
"title": "Session Id"
},
"timestamp": {
"type": "string",
"title": "Timestamp"
}
},
"type": "object",
"required": [
"playbook_title",
"organization_name",
"executive_summary",
"phases",
"roles",
"communication_templates",
"escalation_procedures",
"legal_considerations",
"contact_list",
"session_id",
"timestamp"
],
"title": "PlaybookResponse"
},
"ValidationError": {
"properties": {
"loc": {
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "integer"
}
]
},
"type": "array",
"title": "Location"
},
"msg": {
"type": "string",
"title": "Message"
},
"type": {
"type": "string",
"title": "Error Type"
}
},
"type": "object",
"required": [
"loc",
"msg",
"type"
],
"title": "ValidationError"
}
}
}
}