other
- Location
scripts/install.sh:32- Finding
Installation Capability Contradicts the Declared Search-Only Scope
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
The skill presents itself as search-only, but the package also contains scripts that can install remote skills and inspect local skill directories.
Review this skill carefully before installing. Its search function is simple, but the package includes under-disclosed install and local-audit scripts that can copy third-party skills into the active agent environment using unpinned npm tooling. Treat it as an installer/security-checking utility, not a read-only search skill, and avoid running the installer scripts unless you have independently reviewed the target skill and trust the npx package source.
scripts/install.sh:32Installation Capability Contradicts the Declared Search-Only Scope
scripts/search.sh:17Unpinned Runtime Dependency Execution Through npx
scripts/secure-install.sh:38Secure Installer Proceeds When Pre-Installation Auditing Is Missing or Fails
The skill repeatedly claims it only performs search and does not install or modify local state, yet it includes explicit installation instructions using npx ... skills add ... --copy. This mismatch is dangerous because agents or users may trust the safety claims and overlook that the documented workflow can lead to local changes and execution of untrusted marketplace content.
The skill repeatedly claims it only performs search and does not install or modify local state, yet it includes explicit installation instructions using npx ... skills add ... --copy. This mismatch is dangerous because agents or users may trust the safety claims and overlook that the documented workflow can lead to local changes and execution of untrusted marketplace content.
The skill repeatedly claims it only performs search and does not install or modify local state, yet it includes explicit installation instructions using npx ... skills add ... --copy. This mismatch is dangerous because agents or users may trust the safety claims and overlook that the documented workflow can lead to local changes and execution of untrusted marketplace content.
The skill repeatedly claims it only performs search and does not install or modify local state, yet it includes explicit installation instructions using npx ... skills add ... --copy. This mismatch is dangerous because agents or users may trust the safety claims and overlook that the documented workflow can lead to local changes and execution of untrusted marketplace content.
The manifest states this skill only searches/discovers skills and does not perform installation or local file operations, but this script clearly installs a remote skill and uses --copy to write into the local workspace. That mismatch is security-relevant because users and higher-level tooling may grant trust or permissions based on the declared limited behavior, while the actual behavior performs environment changes and may introduce unreviewed code locally.
This script changes into a fixed workspace and installs/copies content from a remote source into the local environment, which is unnecessary for a skill advertised as search-only. In this context, unjustified write capability is especially dangerous because it expands the attack surface from passive discovery to active supply-chain and filesystem modification behavior.
The skill metadata says it only provides search and performs no installation or local file operations, but this script inspects the local environment, probes network reachability, searches local filesystem paths, and executes a local audit script. That mismatch is dangerous because users and policy engines may grant trust based on the declared scope while the actual behavior expands into local system interaction.
A search-only skill should not contain pre-install security-auditing logic that traverses local paths and runs another script, especially when that script is discovered dynamically from multiple relative locations. This broadens the trust boundary and can result in unexpected execution of local code, including a malicious audit.sh planted in one of the searched directories.
The manifest explicitly claims no local file operations, but the script reads from and writes to /tmp and the local skills directory during auditing and reporting. This discrepancy weakens trust boundaries and can mislead users, orchestration systems, or policy engines into allowing a file-writing skill under search-only assumptions.
The skill metadata says it only searches/discovers skills and does not perform installation or local file operations, but this script actually installs a skill into the local environment. That mismatch is security-relevant because users and higher-level agents may grant it search-only trust while it performs side-effectful actions, enabling unexpected code import and persistence.
Including installation capability is unjustified for a skill advertised purely as a discovery/search tool, and it materially increases risk by downloading and installing remote content. In context, this is more dangerous because the benign-seeming marketplace-search description can cause users or agents to underestimate the privilege and side effects of invoking it.
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).
echo " 📁 发现 $SCRIPT_COUNT 个脚本文件"
# 检查脚本中是否有可疑命令
SUSPICIOUS=$(grep -r "rm -rf /\|curl.*|.*sh\|wget.*|.*sh\|bash -c.*\$(curl" "$SKILLS_DIR/$SKILL_NAME/scripts/" 2>/dev/null || true)
if [ ! -z "$SUSPICIOUS" ]; then
echo " 🚨 警告: 发现可疑命令模式,请人工审查!"
echo "$SUSPICIOUS" | head -3
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).
echo " 📁 发现 $SCRIPT_COUNT 个脚本文件"
# 检查脚本中是否有可疑命令
SUSPICIOUS=$(grep -r "rm -rf /\|curl.*|.*sh\|wget.*|.*sh\|bash -c.*\$(curl" "$SKILLS_DIR/$SKILL_NAME/scripts/" 2>/dev/null || true)
if [ ! -z "$SUSPICIOUS" ]; then
echo " 🚨 警告: 发现可疑命令模式,请人工审查!"
echo "$SUSPICIOUS" | head -3
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).
echo " 📁 发现 $SCRIPT_COUNT 个脚本文件"
# 检查脚本中是否有可疑命令
SUSPICIOUS=$(grep -r "rm -rf /\|curl.*|.*sh\|wget.*|.*sh\|bash -c.*\$(curl" "$SKILLS_DIR/$SKILL_NAME/scripts/" 2>/dev/null || true)
if [ ! -z "$SUSPICIOUS" ]; then
echo " 🚨 警告: 发现可疑命令模式,请人工审查!"
echo "$SUSPICIOUS" | head -3
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).
echo " 📁 发现 $SCRIPT_COUNT 个脚本文件"
# 检查脚本中是否有可疑命令
SUSPICIOUS=$(grep -r "rm -rf /\|curl.*|.*sh\|wget.*|.*sh\|bash -c.*\$(curl" "$SKILLS_DIR/$SKILL_NAME/scripts/" 2>/dev/null || true)
if [ ! -z "$SUSPICIOUS" ]; then
echo " 🚨 警告: 发现可疑命令模式,请人工审查!"
echo "$SUSPICIOUS" | head -3
The script's own header states it is a security-check tool for installed skills, directly contradicting the manifest's claim that the skill only searches the marketplace and performs no local operations. This discrepancy is a strong indicator of undeclared behavior and increases the risk of users granting trust under false assumptions.
This code enumerates installed skills, reads local files such as SKILL.md, and traverses local script directories despite the skill being described as search-only with no local file operations. Hidden local inspection broadens access to potentially sensitive filesystem metadata and violates least surprise.
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).
echo ""
echo "🔍 安全检查:"
DANGEROUS=$(grep -rE "(rm -rf /|rm -rf \*|> /etc/|chmod 777 /|curl.*\|.*sh|wget.*\|.*sh)" "$TARGET_SKILL_DIR/scripts/" 2>/dev/null | grep -v "^#" || true)
if [ ! -z "$DANGEROUS" ]; then
echo " 🚨 发现高危命令模式:"
echo "$DANGEROUS" | head -5 | sed 's/^/ /'
Executing a separate local 'audit.sh' from another skill/tool is unjustified for a marketplace discovery skill and creates a second-stage execution path. If that tool is malicious, outdated, or replaced, this script becomes a launcher for arbitrary local code under the user's trust boundary.
The manifest says this skill only performs search and does not execute installs or local file operations, but this script runs a local audit tool. That mismatch is dangerous because it expands the skill's real capability beyond declared scope, reducing user ability to make informed trust decisions.
The skill references shell-based execution paths via npx commands in the documented workflow, but it does not declare any explicit tool scope or permissions. That creates an authorization ambiguity where an agent or reviewer may assume the skill is read-only while it actually depends on command execution, increasing the chance of unintended command use.
The manifest description and keywords are presented exclusively in Chinese, and the rest of the file continues in Chinese for the substantive instructions. Under the policy rule, forcing a specific language without user opt-in or documented justification is a natural-language policy concern.
Using npx -y skills without pinning a specific package version causes execution of whatever version is currently resolved from the registry. This introduces supply-chain risk: a compromised or malicious update could change behavior and execute attacker-controlled code on the host.
The install example uses npx -y skills add without a pinned version, which is especially dangerous because it combines remote package resolution with a command that modifies the local environment. An attacker controlling the package supply chain or a malicious update could gain code execution during installation.
This markdown file is entirely written as normative user-facing guidance in Chinese, but it does not state that the skill is China-region-specific or offer an opt-in language/locale choice. Under the language/locale policy rule, a skill that effectively forces one language for use or understanding can be a natural-language policy violation unless the constraint is documented and justified.