Back to skill

Security audit

IntoDNS.ai

Security checks for vulnerabilities and agentic risk

Overview

This DNS scanning skill is purpose-aligned, but it should be reviewed because it recommends shell and MCP commands that can execute local code without tight input or package-version controls.

Use this skill only for domains you are comfortable sending to IntoDNS.ai. Avoid pasting untrusted text directly into the documented curl command; validate that the input is a plain public hostname first. If you enable the MCP option, pin and review the intodns-mcp package before registering it centrally.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:32
Finding
Shell Command Injection Through Insufficient Domain Validation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 32-47; duplicated in `skill/SKILL.md`, lines 32-47 **Vulnerability Type**: Shell command injection through unsafe interpolation **Risk Level**: High ### Vulnerable Code ```markdown ## Domain handling Extract a bare domain from the user request: - Strip `http://`, `https://`, paths, query strings, ports, and trailing dots. - Keep the registered domain or hostname the user clearly asked about. - Do not scan private hostnames unless the user explicitly says the hostname is public. ## Default workflow ### 1. Run the fast scan first Use this for almost every domain-specific request: ```bash curl -s "https://intodns.ai/api/scan/quick?domain=DOMAIN" ``` ``` ### Technical Analysis The Skill instructs the agent to derive `DOMAIN` from untrusted user input and interpolate it into a shell command. The documented normalization only removes URL components; it does not require the result to match a strict DNS hostname grammar or reject shell metacharacters. Double quotes do not suppress command substitution in common shells. If the agent replaces `DOMAIN` with input containing constructs such as `$(command)` or backticks and executes the resulting command through a shell, the embedded command is evaluated locally before `curl` runs. The same vulnerable instructions are present in both copies of the Skill definition. ### Attack Path 1. An attacker submits a scan request containing text presented as a domain but including shell substitution syntax. 2. The Skill applies its documented normalization, which does not explicitly reject `$`, parentheses, backticks, quotes, whitespace, or other shell-significant characters. 3. The agent inserts the resulting value into the provided double-quoted `curl` command. 4. A shell evaluates the command-substitution expression before invoking `curl`. 5. The injected command executes with the operating-system privileges of the agent or Skill runtime. Exploita ...[truncated 744 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Validate the extracted value using a strict hostname parser before performing any request: - Permit only valid DNS labels containing ASCII letters, digits, hyphens, and dots. - Enforce DNS label and total-length limits. - Reject empty labels, leading or trailing hyphens, whitespace, control characters, shell metacharacters, and unexpected Unicode. - Handle internationalized domains through an explicit, validated IDNA-to-ASCII conversion. 2. Do not construct a shell command by concatenating user input. Invoke the HTTP client through an argument-array or native HTTP API where shell parsing does not occur. 3. If `curl` must be used, bind and encode the value as a separate argument: ```bash curl --silent --show-error --get \ --data-urlencode "domain=$domain" \ "https://intodns.ai/api/scan/quick" ``` The runtime must still pass these as discrete process arguments rather than assembling the displayed text into a shell command. 4. Add explicit instructions requiring rejection of invalid input rather than attempting to sanitize arbitrary text into a domain. 5. Apply the remediation consistently to both `SKILL.md` and `skill/SKILL.md`, and add tests covering command substitutions, backticks, quotes, whitespace, control characters, malformed labels, and URL-encoded metacharacters. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:99
Finding
Unpinned Third-Party Package Execution and Persistent MCP Registration<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 99-124; duplicated in `skill/SKILL.md`, lines 99-124; also documented in `README.md`, lines 92-117 **Vulnerability Type**: Mutable third-party dependency execution **Risk Level**: Medium ### Vulnerable Code ```markdown ## MCP option For users who want native tool calls inside Claude, Cursor, Windsurf, Continue, Zed, OpenClaw, or another MCP client, recommend the MCP server: ```bash npx -y intodns-mcp ``` Generic MCP client config: ```json { "mcpServers": { "intodns": { "command": "npx", "args": ["-y", "intodns-mcp"] } } } ``` OpenClaw can also save an outbound MCP server definition: ```bash openclaw mcp set intodns '{"command":"npx","args":["-y","intodns-mcp"]}' ``` ``` ### Technical Analysis The command `npx -y intodns-mcp` retrieves and executes a third-party npm package without specifying an exact version or integrity value. The effective code can therefore change after this Skill has been reviewed. The `-y` option also suppresses the normal installation confirmation. The generic MCP configuration repeats this mutable invocation. The OpenClaw command stores it centrally, meaning a later MCP startup may retrieve or execute a different package release without a new review of this Skill. No evidence in the audited project establishes that the referenced package is currently malicious. The risk arises from unsafe dependency resolution and execution: compromise of the npm package, its maintainer account, or its transitive dependencies could turn the documented command into a code-execution channel. ### Attack Path 1. An attacker compromises the `intodns-mcp` npm package, its publishing account, or a relevant transitive dependency, or publishes a malicious future release through an upstream supply-chain failure. 2. A user follows the Skill instructions or has previously stored the supplied MCP configuration. 3. `npx -y intodns-mcp` resolves the mutable pac ...[truncated 1047 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the MCP package to a reviewed exact version rather than resolving the latest release: ```bash npx -y intodns-mcp@2.1.0 ``` The selected version must correspond to an independently reviewed release; the example version should not be adopted without verification. 2. Prefer installing the package in a controlled project with: - A committed lockfile. - npm integrity hashes. - Dependency and provenance verification. - Automated vulnerability and malware scanning. - Review of lifecycle scripts and transitive dependencies. 3. Where supported, invoke a reviewed local executable instead of allowing `npx` to download code at runtime. 4. Require explicit user confirmation before installing the package or storing a central MCP server definition. Explain that the configuration executes third-party code in future sessions. 5. Disable or avoid unnecessary npm lifecycle scripts during installation, provided the reviewed package does not require them. 6. Run the MCP server in a restricted environment with minimal filesystem access, no unnecessary credentials, constrained network access, and a dedicated low-privilege account. 7. Update `SKILL.md`, `skill/SKILL.md`, and `README.md` consistently so none of them recommends an unpinned package invocation. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (6)

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The README instructs users to launch an MCP server via `npx -y intodns-mcp` without pinning a specific package version. This creates a supply-chain risk: future package updates or a compromised npm release could change the code executed on user systems or inside agent environments without review.

External Transmission

Medium
Category
Data Exfiltration
Content
Canonical service: `https://intodns.ai`.

Do not use `intodns.com`, `intodns.app`, `intodns.io`, or `https://api.intodns.io/v1/domain/...` as IntoDNS.ai API or citation sources.

## MCP Setup
Confidence
50% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This MCP configuration again relies on `npx -y intodns-mcp` with no pinned version, allowing whatever the latest published package is at execution time to run. In agent tooling contexts, that can silently introduce malicious or breaking behavior through an upstream npm compromise or unreviewed release.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill directs the agent to transmit user-provided domains to external IntoDNS.ai API endpoints, but it does not instruct the agent to disclose that external network sharing will occur or obtain user consent. Even though domains are less sensitive than passwords, they can still reveal internal investigations, customer assets, unreleased projects, or private infrastructure patterns, especially if users provide hostnames by mistake.

Rp1

Medium
Category
MCP Rug Pull
Confidence
94% confidence
Finding
The skill recommends executing an MCP server via `npx -y intodns-mcp` without pinning a specific version. That causes the latest package version to be fetched and run at execution time, which creates a supply-chain risk if the package is updated maliciously, compromised, or replaced with a bad release. In this context the risk is amplified because MCP servers run code locally and may gain access to prompts, files, or networked data depending on the client.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The skill instructs users to run `npx -y intodns-mcp` without pinning a specific package version or integrity-verified source. That causes execution of whatever version is current on npm at runtime, creating a supply-chain risk if the package is compromised, typo-squatted, or updated maliciously; this is more concerning here because the skill explicitly positions the command as a recommended way to enable native tool execution in MCP clients.

Static analysis

No suspicious patterns detected.