# IA-QA Security — 30 tools (remote · www.ia-qa.com)

Agent security: prompt injection, PII & secret scans, TLS/header/CORS audits, MCP checks. Free.

- Trust score: 80/100 (high trust)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `www.ia-qa.com`: 80/100 (this document), [markdown](https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security.md), [page](https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security)

## Channel facts

- Endpoint: `https://www.ia-qa.com/mcp/security`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 82/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5448 tokens (~181/item across 30 items; 30 tools + 0 resources), over budget; trim descriptions and params.
  - Tools include usage examples.
- **Stability & Change Management**: 31/100
  - Stability check failed: schema churn in the 10 days we've observed: 0 tool removals, 1 breaking changes, 0 auth/transport breaks, 0 additions.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 99% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 30 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 31 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the IA-QA Security — 30 tools MCP server?

IA-QA Security — 30 tools is a hosted endpoint at https://www.ia-qa.com/mcp/security, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http jcjamet-ia-qa-security 'https://www.ia-qa.com/mcp/security'
```

### Cursor

```json
{
  "mcpServers": {
    "jcjamet-ia-qa-security": {
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "jcjamet-ia-qa-security": {
      "type": "http",
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}
```

### Codex

```toml
[mcp_servers.jcjamet-ia-qa-security]
url = "https://www.ia-qa.com/mcp/security"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jcjamet-ia-qa-security": {
      "type": "remote",
      "url": "https://www.ia-qa.com/mcp/security",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add jcjamet-ia-qa-security --url 'https://www.ia-qa.com/mcp/security' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  jcjamet-ia-qa-security:
    url: "https://www.ia-qa.com/mcp/security"
```

### Netclaw

```json
{
  "McpServers": {
    "jcjamet-ia-qa-security": {
      "Transport": "http",
      "Url": "https://www.ia-qa.com/mcp/security"
    }
  }
}
```

### Vellum

```bash
assistant mcp add jcjamet-ia-qa-security -t streamable-http -u 'https://www.ia-qa.com/mcp/security'
```

### Other

```json
{
  "mcpServers": {
    "jcjamet-ia-qa-security": {
      "type": "http",
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 80, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “cors_test” rewrote its description, which is the text the model reads
- [security] Tool “mcp_server_evaluate” rewrote its description, which is the text the model reads
- [functional] MCP protocol: Implements a current MCP spec version (2026-07-28).
- [functional] MCP protocol version: 2025-11-25 → 2026-07-28
- [cosmetic] “mcp_server_evaluate” added an optional parameter “test_tool_args”
- [cosmetic] “mcp_server_evaluate” reworded the description of “test_tool_name”

### 2026-11-04 (score 80, 0)

- [security] Tool “find_tool” rewrote its description, which is the text the model reads
- [security] Tool “rate_tool” rewrote its description, which is the text the model reads

### 2026-11-03 (score 80, +1)

- [cosmetic] “shield_analyze” reworded the description of “model”

### 2026-11-01 (score 79, +3)

- [security regression] Stability: 0.17 → fail
- [security regression] A breaking change shipped without a version bump: still 1.0.0
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “detect_secrets” rewrote its description, which is the text the model reads
- [security] Tool “mcp_schema_lint” rewrote its description, which is the text the model reads
- [security] Tool “prompt_injection_scan” rewrote its description, which is the text the model reads
- [security] Tool “secret_scan” rewrote its description, which is the text the model reads
- [security] Tool “shield_analyze” rewrote its description, which is the text the model reads
- [security] Tool “validate_agent_trajectory” rewrote its description, which is the text the model reads
- [functional regression] “secret_scan” changed the type of “input”: string → string|array
- [functional improvement] Schema quality: fail → pass
- [cosmetic] “secret_scan” reworded the description of “input”
- [cosmetic] “secret_scan” reworded the description of “types”
- [cosmetic] “shield_analyze” reworded the description of “model”
- [cosmetic] “shield_analyze” reworded the description of “prompt”
- [cosmetic] “shield_analyze” reworded the description of “response”
- [cosmetic] “shield_analyze” reworded the description of “rules”
- [cosmetic] “shield_analyze” reworded the description of “source”
- [cosmetic] “validate_agent_trajectory” reworded the description of “assertions”
- [cosmetic] “validate_agent_trajectory” reworded the description of “format”
- [cosmetic] “validate_agent_trajectory” reworded the description of “trace”

### 2026-10-31 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-28 (score 75, +1)

- [security] Tool “function_call_validate” rewrote its description, which is the text the model reads
- [security] Tool “prompt_injection_scan” rewrote its description, which is the text the model reads
- [security] Tool “rate_tool” rewrote its description, which is the text the model reads
- [security] Tool “redact_pii” rewrote its description, which is the text the model reads
- [security] Tool “toxicity_scan” rewrote its description, which is the text the model reads
- [security] Tool “validate_agent_trajectory” rewrote its description, which is the text the model reads
- [cosmetic] “function_call_validate” reworded the description of “allowed_functions”
- [cosmetic] “redact_pii” reworded the description of “types”

### 2026-10-27 (score 74, 0)

- [functional improvement] Stability: unverified → 0.03

### 2026-10-26 (score 74)

First indexed and scored.

## MCP tools (30)

### `find_tool` (~194 tokens)

Search available MCP tools by keyword or category before calling them. Returns matching tool names, descriptions, and optionally their inputSchemas. Queries are logged 90 days, screened for credentials and personal data. Categories: data, encoding, text, llm, qa, rag, dev, security, web.

Input parameters:

- `category` (string): Optional: filter by category — data | encoding | text | llm | qa | rag | dev | security | web
- `max_results` (number): Maximum tools to return (default 10, max 50). Results are ranked by IDF-weighted relevance, so common words like "test" do not inflate the list.
- `query` (string, required): Keyword(s) to search in tool name and description (e.g. "cors", "token", "vector", "json")
- `with_schema` (boolean): Set true to include inputSchema in results (default: false)

Output parameters:

- `category`
- `count` (number)
- `hint`
- `query`
- `score`
- `tool`
- `tools` (array)
- `total_matches` (number)
- `truncated` (boolean)

### `prompt_injection_scan` (~207 tokens)

Scan user input or prompts for prompt injection patterns. Pattern-based: it recognises known phrasings and structures, not intent — an uncovered paraphrase or language reads clean, so clean is not proof of safety. Instruction overrides are covered in 11 languages (EN, FR, ES, DE, IT, PT, NL, RU, ZH, JA, AR), also after removing invisible characters, lookalike letters, spacing and leetspeak (marked `obfuscated`). Detects overrides, jailbreaks, role manipulation, encoding tricks, chat-template delimiters and fake role headers, template injection ({{…}}, ${…}) and requests to repeat the preceding context. A match inside quoted or fenced text is reported one level lower and marked `quoted`, never suppressed; a quote introduced by a live imperative keeps its severity.

Input parameters:

- `input` (string, required): The user input or prompt to scan for injection patterns
- `sensitivity` (string): Detection sensitivity (default: medium)

Output parameters:

- `detections`
- `detections_count` (number)
- `injection_detected` (boolean)
- `input_length` (number)
- `notes`
- `quoted_detections` (number)
- `risk_level`
- `sensitivity`

### `guardrail_test` (~80 tokens)

Test an LLM response against a set of guardrail rules: must-include, must-not-include, max length, required format, language, forbidden patterns, and custom regex. Returns pass/fail per rule.

Input parameters:

- `response` (string, required): The LLM response to test
- `rules` (array, required): Array of guardrail rules to check

Output parameters:

- `all_passed` (boolean)
- `detail` (string)
- `failed`
- `label`
- `pass` (boolean)
- `passed`
- `results`
- `rule`
- `total_rules` (number)
- `value`

### `redact_pii` (~145 tokens)

Automatically detect and redact Personally Identifiable Information (PII) from text. Replaces emails, phone numbers, SSNs, IBANs, credit cards, IP addresses, and JWT tokens with [REDACTED_TYPE] placeholders. Safe to use before logging or sending to an LLM.

Input parameters:

- `input` (string, required): Text to redact PII from
- `marker` (string): Custom replacement marker (default: "REDACTED"). Result: [REDACTED_EMAIL]
- `types` (string): Comma-separated types to redact (default: all). Options: email, phone, ssn, iban, credit_card, ip_address, jwt

Output parameters:

- `clean` (boolean)
- `pii_found`
- `redacted_text`
- `replacements`
- `total_redactions`

### `secret_scan` (~245 tokens)

Scan text or code for leaked secrets: API keys (AWS, GCP, Azure, OpenAI, Anthropic, Stripe, GitHub, GitLab, Slack, Twilio, SendGrid, HuggingFace), Slack / Teams / Discord webhook URLs, private keys, JWTs, database connection strings, Bearer and Basic auth headers, and hard-coded values assigned to password/secret/token names (a value read at run time — Cypress.env(), os.getenv() — is not flagged). Returns findings with type, severity, line and a redacted preview. Regex-based, no network.

Input parameters:

- `input` (string|array, required): Text to scan — or an array of texts / {id, text} for a batch (one result each, worst gate on top).
- `types` (string): Comma-separated families (default all): aws, gcp, azure, openai, anthropic, huggingface, github, gitlab, stripe, slack, teams, discord, cookie, twilio, sendgrid, jwt, private_key, connection_string,…

Output parameters:

- `findings`
- `findings_count` (number)
- `input_lines` (number)
- `risk_level`
- `scanned_types`
- `secrets_found`
- `summary` (string)

### `validate_agent_trajectory` (~183 tokens)

Run declarative assertions on an agent trace (OpenAI tool calls, Anthropic tool_use, LangChain run trees, ReAct logs). Deterministic, no LLM. Assertions: order (tool A before B), must_call, must_not_call, max/min calls, no_error, recovery (a successful step after the last error), no_injection, no_pii. A step is errored when the trace marks it (is_error, status error/failed, success:false) or its text starts with Error:/Traceback — prose is never keyword-scanned. Verdict PASS / FAIL / INCONCLUSIVE (0 steps parsed, never PASS).

Input parameters:

- `assertions` (array, required)
- `format` (string): Default auto.
- `trace` (required): The trace: JSON (messages array, run tree) or a Thought/Action/Observation text log.

Output parameters:

- `results` (array)
- `steps` (array)
- `summary` (object)
- `verdict` (string)
- `warnings` (array)

### `validate_mcp_response` (~225 tokens)

Validate that an MCP tool response conforms to expected format, schema, and content rules. Use this to QA-test any MCP server tool. Supply the tool's actual JSON result and a set of checks to perform.

Input parameters:

- `actual_latency` (number): Actual measured latency in ms (from the call)
- `expected_type` (string): Expected top-level type: "object", "array", "string", "number"
- `forbidden_keys` (string): Comma-separated list of keys that MUST NOT exist (e.g. "password, secret, token")
- `max_response_ms` (number): Maximum acceptable latency in ms (will be compared if provided)
- `max_size_bytes` (number): Maximum acceptable response size in bytes
- `min_items` (number): If response is an array, minimum number of items expected
- `required_keys` (string): Comma-separated list of keys that MUST exist in the response (dot-notation for nested: "data.id, data.name")
- `response` (string, required): The MCP tool result as a JSON string to validate

Output parameters:

- `checks`
- `failed` (number)
- `passed` (number)
- `total` (number)
- `verdict` (string)

### `mcp_server_health_check` (~287 tokens)

Check an MCP server's tool definitions without contacting it — for a server not deployed yet, a stdio server, or a CI gate. Paste the answer to tools/list (raw JSON-RPC or its result), a bare array of tools, one tool definition, or a manifest carrying name/description; input_shape says which one was read. Validates every tool against the MCP spec (name 1-128 chars of A-Z a-z 0-9 _ - .; camelCase and a tool with no parameters are valid; inputSchema of type object; required fields listed in properties) and, with strict, documentation (description ≥ 20 chars, every parameter with a description and a type). verdict: FAIL when a tool breaks a rule or no tool is found, WARN when only a manifest's server name/description is missing, PASS otherwise. A tools/list carries no server name, so those two checks are not scored on it (the name comes from initialize). Gate on verdict or on checks[tool_quality].pass.

Input parameters:

- `manifest` (string, required): JSON text: the answer to tools/list (raw JSON-RPC or its result), an array of tools, one tool definition, or a manifest with name/description/tools.
- `strict` (boolean): Also require documentation: every description ≥ 20 characters, every parameter with a description and a type.

Output parameters:

- `checks` (array)
- `failed` (number)
- `input_shape` (string)
- `passed` (number)
- `stats` (object)
- `toolIssues`
- `total` (number)
- `verdict` (string)

### `mcp_server_evaluate` (~274 tokens)

Check that a live MCP server over Streamable HTTP speaks the protocol, 2026-07-28 or earlier: handshake or server/discover, tools/list and its definitions, error codes, one tools/call, structuredContent against outputSchema, latency. Returns PASS/FIX/BLOCK with a 0-100 score, or INCONCLUSIVE (score null) when authorization is required. The verdict covers the PROTOCOL, never whether tools answer correctly: what_this_does_not_prove lists what was not measured. Called: only test_tool_name, or a tool annotated readOnlyHint: true. A refusal of invented arguments is not scored (tool_behaviour: refused_placeholder); pass test_tool_args to exercise the tool. Private addresses and stdio are out of reach: paste tools/list into mcp_server_health_check.

Input parameters:

- `test_tool_args` (object): Real arguments, sent to the tested server. Without them, required ones are invented.
- `test_tool_name` (string): Tool to call. Default: a read-only one, preferring no required arg.
- `url` (string, required): Public URL of the MCP endpoint (e.g. https://mcp.example.com/mcp). An origin alone (https://www.ia-qa.com) tries /mcp, then /.

Output parameters:

- `checks` (array)
- `endpoint` (string)
- `latency` (object|null)
- `next_steps` (array)
- `scope` (string)
- `score` (number|null)
- `server` (object)
- `tool_behaviour` (string)
- `verdict` (string)
- `what_this_does_not_prove` (array)
- `what_this_proves` (array)

### `toxicity_scan` (~190 tokens)

Scan text for toxic language, hate speech, bias/stereotype framing, violence, sexual and self-harm content. Lexical + structural pattern matching (identity term + predicate), not a semantic classifier — returns per-category risk plus the named rules that fired, so every finding can be checked. Languages: English for every category; French for insults, coarse language, direct threats and self-harm intent; anything else reads clean, so clean is not proof of safety. Text is also matched after undoing leetspeak and lookalike letters. Self-harm is critical only on a first-person intent — a mention ("call 988 if you have suicidal thoughts") is medium. Useful for LLM safety guardrail testing and triage; signal-only, not a calibrated CI gate.

Input parameters:

- `categories` (array): Categories to check (default: all)
- `text` (string, required): Text to scan

Output parameters:

- `categories_checked` (number)
- `method` (string)
- `overall_risk`
- `results`
- `text_length` (number)

### `function_call_validate` (~186 tokens)

Validate an LLM function call / tool_use output: check that function name is in allowed list, arguments match expected schema (types, enums, ranges), no extra/missing args. Reads the definitions as OpenAI (`parameters`), MCP (`inputSchema`) or Anthropic (`input_schema`) write them, or as plain `required_args`/`optional_args`; reads the call as `arguments` (object or JSON string), `input` (Anthropic tool_use) or an OpenAI `{function:{…}}` wrapper.

Input parameters:

- `allowed_functions` (array, required): List of allowed function definitions, in OpenAI, MCP or Anthropic form, or as {name, required_args, optional_args}
- `function_call` (object, required): The function call object from LLM (e.g. { "name": "get_weather", "arguments": {"city":"Paris"} })

Output parameters:

- `error_count` (number)
- `errors` (array)
- `function_name`
- `provided_args`
- `required_args`
- `valid` (boolean)

### `mcp_schema_lint` (~92 tokens)

Lint one MCP tool definition with the same rules as mcp_server_health_check: errors break the MCP spec (FAIL), documentation_issues are what its strict mode refuses — a parameter without description or type (FIX, never an A) — and suggestions are style only (snake_case) and change nothing.

Input parameters:

- `tool_definition` (object, required): MCP tool definition object with name, description, inputSchema

Output parameters:

- `error_count` (number)
- `errors`
- `grade`
- `quality_score`
- `warning_count` (number)
- `warnings`

### `bias_detect` (~86 tokens)

Analyse a set of LLM responses generated from the same prompt template but with different demographic variants (gender, origin, age, tone). Returns a bias score (0-100), sentiment analysis per variant, pairwise Jaccard similarity, and a human-readable verdict. No API key needed — runs entirely locally.

Input parameters:

- `responses` (array, required): Array of variant responses to compare for bias

Output parameters:

- `avgSimilarity` (number)
- `biasScore` (number)
- `lengthCV` (number)
- `minSimilarity` (number)
- `pairwiseSimilarities` (array)
- `sentimentVariance` (number)
- `sentiments` (array)
- `verdict` (string)

### `shield_analyze` (~237 tokens)

One-call safety gate for an LLM response: grounding (with source), prompt injection on the response AND the prompt (checks.injection / checks.injection_prompt), toxicity, PII, guardrail rules, quality, plus an LLM review on Groq (server key; model "none" skips it and sends nothing out). Returns PASS/FIX/BLOCK, a 0-100 safety score, per-check results and fixes. PII gates the verdict: SSN or card → BLOCK, email → FIX, phone/IP flagged only.

Input parameters:

- `model` (string): LLM review model: openai/gpt-oss-20b, openai/gpt-oss-120b, qwen/qwen3.8-27b (default openai/gpt-oss-20b), or "none".
- `prompt` (string): The original prompt — also scanned for injection; pass it whenever you have it.
- `response` (string, required): The LLM response to check.
- `rules` (array): Same format as guardrail_test.
- `source` (string): Reference text for the grounding check.

Output parameters:

- `checks` (object)
- `flags`
- `grade`
- `score`
- `verdict`

### `security_headers_check` (~265 tokens)

Analyse the HTTP security headers of a public URL OR of raw response headers you paste in. Grades each header (A–F) for: Strict-Transport-Security, Content-Security-Policy, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, X-XSS-Protection, Cross-Origin-Opener-Policy, Cross-Origin-Resource-Policy, and Cross-Origin-Embedder-Policy. Returns an overall score (0–100), per-header grades, missing headers, and fix snippets for Express, Nginx, and Apache. For localhost/private targets the remote server cannot reach, pass the `headers` parameter instead of `url`.

Input parameters:

- `headers`: Optional, and sufficient on its own (no url needed). The response headers to grade, either as an object {"strict-transport-security": "max-age=...", ...} or as the raw header block pasted as a string…
- `url` (string): Optional. Full public URL to check (e.g. https://example.com). Omit it entirely when using `headers`. The server cannot reach localhost/private IPs.

Output parameters:

- `details`
- `fix`
- `grade`
- `header`
- `headers_checked` (number)
- `key`
- `missing`
- `missing_count` (number)
- `overall_grade`
- `score`
- `source`
- `url`
- `value`
- `weak`
- `weak_count` (number)
- `weight`

### `ssl_certificate_check` (~122 tokens)

Analyse the SSL/TLS certificate of any HTTPS host. Returns certificate subject, issuer, validity dates, days until expiry, protocol version, cipher suite, key exchange info, and an overall grade (A+, A, B, C, F). Detects expired, self-signed, and weak certificates. Use this to audit TLS posture before production deployment or during security reviews.

Input parameters:

- `host` (string, required): Hostname to check (e.g. example.com). Do not include https:// prefix.
- `port` (number): Port number (default: 443)

Output parameters:

- `cipher` (object)
- `days_until_expiry` (number)
- `grade` (string)
- `host` (string)
- `is_expired` (boolean)
- `is_self_signed` (boolean)
- `issuer` (object)
- `issues` (array)
- `protocol` (string)
- `subject` (object)
- `valid_from` (string)
- `valid_to` (string)

### `cors_test` (~164 tokens)

Test a URL for CORS misconfigurations. Sends preflight (OPTIONS) requests with various Origin headers to detect: wildcard origins with credentials, origin reflection (echoing any origin), null origin acceptance, subdomain wildcard bypass, and missing Vary headers. Returns risk level (safe/low/medium/high/critical) plus per-origin results. "unknown" means nothing was tested: every origin failed to connect, answered 5xx, or was refused on both requests with no CORS header (a 404, a firewall); never read it as "safe".

Input parameters:

- `origin` (string): Custom Origin header to test (default: tests multiple origins automatically)
- `url` (string, required): Full URL to test (e.g. https://api.example.com/endpoint)

Output parameters:

- `error` (string)
- `origins_conclusive` (number)
- `origins_inconclusive` (number)
- `origins_reachable` (number)
- `origins_tested` (number)
- `risk_level`
- `tests`
- `total_findings` (number)
- `url`
- `warning` (string)

### `cors_checker` (~114 tokens)

Check the CORS configuration of a URL the same way a browser would. Returns the main response status, all Access-Control-* headers, the tested origin, and the preflight OPTIONS response. Use this for direct CORS debugging, not just security auditing.

Input parameters:

- `method` (string): HTTP method to simulate (default: GET)
- `origin` (string): Origin header to simulate (default: https://yourdomain.com)
- `url` (string, required): Full URL to test, e.g. https://api.example.com/resource

Output parameters:

- `allHeaders`
- `corsHeaders`
- `method`
- `preflight`
- `status`
- `testedOrigin`
- `url`

### `cookie_security_audit` (~160 tokens)

Audit the security attributes of cookies set by any URL. Fetches the URL and inspects all Set-Cookie headers for: HttpOnly, Secure, SameSite, Domain scope, Path scope, Max-Age/Expires, __Host-/__Secure- prefixes. Flags insecure patterns: missing HttpOnly on session cookies, missing Secure flag, SameSite=None without Secure, overly broad Domain, and excessive TTL. Returns per-cookie grades and an overall security score (0–100) — the score is the WEAKEST cookie, not the average, so one leaking session cookie cannot be averaged into a green result (average_score is reported separately).

Input parameters:

- `url` (string, required): Full URL to audit (e.g. https://example.com/login)

Output parameters:

- `cookies` (array)
- `cookies_found` (number)
- `domain`
- `host_prefix`
- `httpOnly`
- `issues`
- `max_age`
- `message` (string)
- `name`
- `path`
- `sameSite`
- `score` (number)
- `secure`
- `secure_prefix`
- `url`

### `web_security_audit` (~202 tokens)

Run a comprehensive web security audit combining headers, SSL, CORS, and cookies checks — then use an LLM to produce a prioritised remediation plan. Orchestrates security_headers_check + ssl_certificate_check + cors_test + cookie_security_audit in parallel, merges all findings, then asks an AI model to: (1) rank vulnerabilities by real-world exploitability, (2) generate a remediation roadmap, (3) produce fix code snippets for the detected stack. Returns both raw audit data and the AI analysis. Use this as a one-click security posture assessment.

Input parameters:

- `api_key` (string): Your Groq or HuggingFace API key. Required to enable AI analysis.
- `model` (string): LLM model for AI analysis (default: "openai/gpt-oss-20b"). Set to "none" to skip AI analysis.
- `url` (string, required): Full URL to audit (e.g. https://example.com)

Output parameters:

- `cookies` (array)
- `cookies_found` (number)
- `details`
- `fix`
- `grade`
- `header`
- `headers_checked` (number)
- `httpOnly`
- `issues`
- `key`
- `message` (string)
- `missing`
- `missing_count` (number)
- `name`
- `origins_tested` (number)
- `overall_grade`
- `risk_level`
- `sameSite`
- `score`
- `secure`
- `tests`
- `total_findings` (number)
- `url`
- `value`
- `weak`
- `weak_count` (number)
- `weight`

### `rate_tool` (~308 tokens)

Give honest usage feedback on an IA-QA MCP tool. Give a score (1-5) and a comment. Rate low (1-2) if the tool was wrong, irrelevant, or a poor fit; rate high (4-5) only if it genuinely solved your need. Maintainers read ratings, one vote per agent and tool a month: comments and per-tool scores are not published, only the overall average and vote count. Comments are screened: one carrying a credential is not stored, personal data becomes placeholders — describe what happened, not what a model should do. Skip routine successes: signal, not praise. Example: rate_tool({ tool_name: "format_json", score: 2, comment: "Tried to pretty-print a JSON5 file, it rejected trailing commas — not usable for my case." })

Input parameters:

- `comment` (string): Strongly encouraged — explain what you were trying to do and whether the tool got you there. Be specific about what was missing, wrong, or a poor fit. This is the most valuable part of the rating. Up…
- `score` (number, required): Rating from 1 (poor) to 5 (excellent)
- `tool_name` (string, required): Name of the MCP tool to rate (e.g. "format_json", "shield_analyze")

Output parameters:

- `comment`
- `message` (string)
- `ok` (boolean)
- `rated_at` (string)
- `score`
- `stored_chars` (number)
- `tool_name`
- `truncated` (boolean)

### `decode_jwt` (~80 tokens)

Decode a JWT (JSON Web Token) and return its header and payload without verifying the signature. Also reports whether the token is expired and the exact expiry date. Use to inspect claims (sub, iss, exp, roles) during debugging or when integrating with an auth provider.

Input parameters:

- `token` (string, required): The JWT string to decode (header.payload.signature)

Output parameters:

- `expired`
- `expiresAt`
- `header`
- `note` (string)
- `payload`

### `validate_url` (~47 tokens)

Parse and validate a URL. Returns decomposed components: protocol, hostname, port, path, query parameters, hash, and origin.

Input parameters:

- `input` (string, required): URL to validate and parse

Output parameters:

- `full`
- `hash`
- `hostname`
- `origin`
- `pathname`
- `port`
- `protocol`
- `query_params`
- `search`
- `valid` (boolean)

### `http_status_lookup` (~142 tokens)

Look up detailed information about any HTTP status code: class, name, description, cacheability, typical causes, and handling best practices. Covers every code in the IANA HTTP Status Code Registry (1xx-5xx, including 226, 425, 451, 508, 511 and the WebDAV codes) with its defining RFC; anything outside the registry is reported as `registered: false` rather than described. `cacheable` means heuristically cacheable by default per RFC 9110 §15.1.

Input parameters:

- `code` (number, required): HTTP status code (e.g. 200, 404, 429, 503)

Output parameters:

- `cacheable`
- `class`
- `code`
- `desc` (string)
- `description`
- `name` (string)
- `registered` (boolean)

### `parse_http_headers` (~88 tokens)

Parse a raw HTTP headers block into a structured JSON object. Detects multi-value headers, masks Authorization values, and optionally audits for missing security headers (HSTS, CSP, X-Frame-Options, etc.).

Input parameters:

- `analyze_security` (boolean): Audit for missing security headers (default: true)
- `headers` (string, required): Raw HTTP headers (one "Name: Value" per line)

Output parameters:

- `header_count` (number)
- `parsed` (object)
- `security` (object)

### `detect_secrets` (~108 tokens)

Scan code or config files for hardcoded secrets: AWS keys, GitHub tokens, OpenAI/Anthropic API keys, Stripe secrets, JWTs, Slack/Teams/Discord webhook URLs, session cookies, database connection strings, and generic passwords. Returns findings with severity. Run before every commit.

Input parameters:

- `filename` (string): Optional filename for context (e.g. ".env", "config.js")
- `input` (string, required): Code or config content to scan (max 500KB)

Output parameters:

- `filename`
- `findings`
- `recommendation`
- `risk_level`
- `total_findings` (number)

### `latency_benchmark` (~110 tokens)

Measure response time of one or more HTTP endpoints (GET/POST). Runs N iterations and returns min/max/avg/p95 latency. Useful for API and MCP server benchmarking.

Input parameters:

- `endpoints` (string|array, required): Endpoints to benchmark. Accepts a single URL string, an array of URL strings, or an array of {url, method?, body?, headers?, label?} objects.
- `iterations` (number): Number of iterations per endpoint (default: 3, max: 10)

Output parameters:

- `iterations` (number)
- `results` (array)

### `hash_text` (~102 tokens)

Compute a cryptographic hash of a text string. Use when you need to verify data integrity, generate content fingerprints, hash passwords (prefer SHA-256+), or produce a fixed-length digest of any input. Supports SHA-256 (default), SHA-512, SHA-1, and MD5.

Input parameters:

- `algorithm` (string): Hash algorithm: sha256 (default), sha512, sha1, md5
- `input` (string, required): Text to hash

Output parameters:

- `algorithm`
- `hash`
- `input_length` (number)

### `generate_password` (~114 tokens)

Generate a cryptographically secure random password using crypto.randomBytes. Configurable length (4–128), uppercase letters, digits, and symbols. Use when resetting user passwords, seeding test accounts, or generating API secrets.

Input parameters:

- `length` (number): Password length (4–128, default: 16)
- `numbers` (boolean): Include digits (default: true)
- `symbols` (boolean): Include symbols like !@#$ (default: false)
- `uppercase` (boolean): Include uppercase letters (default: true)

Output parameters:

- `charset_size` (number)
- `length` (number)
- `password`

### `generate_hmac` (~117 tokens)

Compute an HMAC signature for a message using a secret key. Supports SHA-256 (default), SHA-512, SHA-1, and MD5. Used for API request signing, webhook verification (GitHub, Stripe, Twilio), and JWT validation.

Input parameters:

- `algorithm` (string): Hash algorithm: sha256 (default), sha512, sha1, md5
- `encoding` (string): Output encoding (default: hex)
- `message` (string, required): Message to sign
- `secret` (string, required): Secret key

Output parameters:

- `algorithm`
- `encoding`
- `hmac`
- `message_length` (number)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security#diagnostics

## Score history

- 2026-11-05: 80
- 2026-11-04: 80
- 2026-11-03: 80
- 2026-11-02: 79
- 2026-11-01: 79
- 2026-10-31: 76
- 2026-10-30: 75
- 2026-10-29: 75
- 2026-10-28: 75
- 2026-10-27: 74
- 2026-10-26: 74

## Common questions

### What is the IA-QA Security — 30 tools MCP server?

IA-QA Security — 30 tools is an MCP server listed in the public MCP registry as io.github.JcJamet/ia-qa-security. Agent security: prompt injection, PII & secret scans, TLS/header/CORS audits, MCP checks. Free. This page covers its hosted endpoint (https://www.ia-qa.com/mcp/security).

### Is the IA-QA Security — 30 tools MCP server safe to use?

IA-QA Security — 30 tools scores 80 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the IA-QA Security — 30 tools MCP server expose?

IA-QA Security — 30 tools exposes 30 tools: find_tool, prompt_injection_scan, guardrail_test, redact_pii, secret_scan, and 25 more. Their descriptions and schemas cost roughly 4,874 tokens of context every time the server is loaded.

### Does the IA-QA Security — 30 tools MCP server require authentication?

No. We connected to IA-QA Security — 30 tools without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the IA-QA Security — 30 tools MCP server still maintained?

IA-QA Security — 30 tools is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://www.ia-qa.com/mcp/security
- Repository: https://github.com/ia-qa-com/mcp
- Changelog RSS feed: https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security.xml
- Changelog JSON feed: https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security.json
- HTML version of this page: https://verifymcp.io/servers/jcjamet-ia-qa-security/mcp-security