Back to skill

Security audit

markdown-converter

Security checks for vulnerabilities and agentic risk

Overview

This skill is a plausible Markdown conversion helper, but it directs agents to run an unpinned third-party converter and includes networked/plugin conversion modes without enough scoping or warning.

Review before installing. Use this only in a sandboxed environment for non-sensitive documents unless you pin and vet the markitdown package version, restrict filesystem and network access, and require explicit approval before using Azure Document Intelligence, URLs, transcription/OCR, archives, or third-party plugins.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:8
Finding
Unpinned Third-Party Package Retrieval and Execution<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 8-19 **Vulnerability Type**: Unpinned dependency execution through `uvx` **Risk Level**: Medium ### Vulnerable Code ```markdown Convert files to Markdown using `uvx markitdown` — no installation required. ## Basic Usage ```bash # Convert to stdout uvx markitdown input.pdf # Save to file uvx markitdown input.pdf -o output.md uvx markitdown input.docx > output.md # From stdin cat input.pdf | uvx markitdown ``` ``` ### Technical Analysis The documented commands direct users to execute `markitdown` through `uvx` without specifying an exact package version, dependency lockfile, package hash, or trusted repository configuration. `uvx` may resolve, download, cache, and execute the currently available package and its transitive dependencies. Because the resolved software is not fixed to the version reviewed with this Skill, the effective executable code can change independently of the Skill package. A compromised release, malicious transitive dependency, dependency-confusion event, or unexpected upstream update could therefore run arbitrary code when a user follows the documented instructions. No evidence was found that the currently published `markitdown` package is malicious. The finding concerns the unsafe and non-reproducible dependency execution method documented by the Skill. ### Attack Path 1. An attacker compromises a future `markitdown` release, one of its transitive dependencies, or the package-resolution source used by `uvx`. 2. The user follows the Skill documentation and runs an unpinned command such as `uvx markitdown input.pdf`. 3. `uvx` resolves and downloads the compromised package version or dependency. 4. Package initialization or document-processing code executes with the privileges of the invoking user. 5. The malicious code can access the supplied document and other resources available to that user, potentially including local files, environment variables, credenti ...[truncated 808 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `markitdown` to an exact version that has been reviewed, rather than allowing `uvx` to resolve the latest available release. For example: ```bash uvx --from 'markitdown==<reviewed-version>' markitdown input.pdf ``` 2. Use a lockfile or equivalent dependency manifest that fixes all transitive dependency versions. 3. Verify package artifacts with cryptographic hashes where supported, and obtain packages only from an explicitly configured trusted index. 4. Regularly review and deliberately update the pinned package and its dependency tree instead of accepting upstream changes automatically. 5. Document that the first invocation may access the network, download executable code, and cache dependencies. 6. Run document conversion in a sandbox or container with: - No unnecessary credentials or environment secrets. - Read-only access to input documents where practical. - Write access restricted to a dedicated output directory. - Limited network access. - No administrative or root privileges. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (12)

Vague Triggers

Medium
Confidence
93% confidence
Finding
The description is extremely broad and can match many ordinary requests involving documents, media, URLs, or archives, causing the skill to activate in situations users may not expect. In this skill's context, broad invocation is more dangerous because the tool can process sensitive local files and network-backed inputs such as YouTube URLs and external services.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Using `uvx markitdown` without pinning an exact package/version causes the skill to fetch and execute whatever release is current at runtime. This creates a supply-chain risk: a compromised upstream package, malicious update, or dependency confusion event could result in arbitrary code execution in the agent environment.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This example invokes `uvx markitdown` without a pinned version, so execution depends on the latest available package at run time. If the upstream package or one of its dependencies is compromised, the skill could execute attacker-controlled code while processing user files.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Redirecting output to a file does not reduce the underlying risk that `uvx` may resolve and execute an unpinned package version. The main danger is remote code execution via an unexpected or malicious package update before any document conversion occurs.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This command again relies on `uvx markitdown` without constraining the version, which undermines reproducibility and trust. In an automated agent context, that means future runs may silently execute different code than what was originally reviewed.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Reading from stdin does not change the security property that the tool itself is fetched/executed dynamically and unpinned. An attacker who can influence package resolution or exploit a compromised upstream release could gain code execution in the environment handling potentially sensitive data.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The documentation mentions Azure Document Intelligence and supported media/URL inputs but does not clearly warn that content may be transmitted to external services or plugins. This omission can lead users to process sensitive documents, images, audio, archives, or URLs without informed consent, causing confidentiality and compliance risks.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This usage example repeats the same supply-chain pattern: unpinned execution of a remote package. Because the skill is meant for broad document conversion, it is likely to be reused frequently, increasing exposure to a malicious upstream update over time.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The command processes spreadsheets with an unpinned `uvx` package, again exposing the runtime to arbitrary upstream changes. In agent systems that may handle sensitive enterprise files, executing a compromised converter would have serious confidentiality and integrity consequences.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
This example also dynamically resolves the converter package at execution time, which is unsafe for production automation. A tampered release could run before conversion and access local files, credentials, or the documents being processed.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Even when only providing a file-type hint, the command still depends on an unpinned remote package. The danger is amplified in agent workflows because users may assume the skill is safe and deterministic while the executed code can drift over time.

Rp1

Medium
Category
MCP Rug Pull
Confidence
98% confidence
Finding
This invocation is especially risky because it combines unpinned package execution with an option that sends document content to an external Azure Document Intelligence endpoint. That creates both supply-chain risk from the converter itself and potential data exposure if sensitive PDFs are processed without explicit user awareness and endpoint validation.

Static analysis

No suspicious patterns detected.