Back to skill

Security audit

CHECK

Security checks across malware telemetry and agentic risk

Overview

This package is presented mainly as an environment checker, but it also installs packages, runs generated code, executes arbitrary local commands with possible elevation, and stores/deletes local knowledge files.

Install only if you intentionally want the full development-skills bundle, not just an environment checker. Review or disable the code runner, permission managers, and universal command runner; use a virtual environment or sandbox for package installs and generated code; and require explicit human approval for every command, Docker/Ollama action, or sudo/admin path.

SkillSpector

By NVIDIA
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (52)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
for pkg in packages:
            try:
                print(f"正在安装 {pkg}...")
                result = subprocess.run([sys.executable, "-m", "pip", "install", pkg], 
                                      capture_output=True, text=True, timeout=300)
                if result.returncode == 0:
                    results.append(f"✓ 成功安装 {pkg}")
Confidence
91% confidence
Finding
result = subprocess.run([sys.executable, "-m", "pip", "install", pkg], capture_output=True, text=True, timeout=300)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
"""
        try:
            if language.lower() == "python":
                result = subprocess.run([sys.executable, file_path], 
                                      capture_output=True, text=True, timeout=30)
                return {
                    "exit_code": result.returncode,
Confidence
98% confidence
Finding
result = subprocess.run([sys.executable, file_path], capture_output=True, text=True, timeout=30)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 运行测试
            if language.lower() == "python":
                # 使用pytest或unittest运行测试
                result = subprocess.run([sys.executable, test_file_path], 
                                      capture_output=True, text=True, timeout=30)
                return {
                    "test_file": test_file_path,
Confidence
99% confidence
Finding
result = subprocess.run([sys.executable, test_file_path], capture_output=True, text=True, timeout=30)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
"stderr": result.stderr
                }
            elif language.lower() == "javascript":
                result = subprocess.run(["node", file_path], 
                                      capture_output=True, text=True, timeout=30)
                return {
                    "exit_code": result.returncode,
Confidence
97% confidence
Finding
result = subprocess.run(["node", file_path], capture_output=True, text=True, timeout=30)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
"stderr": result.stderr
                }
            elif language.lower() == "javascript":
                result = subprocess.run(["node", test_file_path], 
                                      capture_output=True, text=True, timeout=30)
                return {
                    "test_file": test_file_path,
Confidence
98% confidence
Finding
result = subprocess.run(["node", test_file_path], capture_output=True, text=True, timeout=30)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
"stderr": result.stderr
                }
            elif language.lower() == "bash" or language.lower() == "shell":
                result = subprocess.run(["bash", file_path], 
                                      capture_output=True, text=True, timeout=30)
                return {
                    "exit_code": result.returncode,
Confidence
100% confidence
Finding
result = subprocess.run(["bash", file_path], capture_output=True, text=True, timeout=30)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
for pkg in packages_to_install:
            try:
                print(f"正在安装 {pkg}...")
                result = subprocess.run([sys.executable, "-m", "pip", "install", pkg], 
                                      capture_output=True, text=True, timeout=300)
                if result.returncode == 0:
                    install_result = f"✓ 成功安装 {pkg}"
Confidence
97% confidence
Finding
result = subprocess.run([sys.executable, "-m", "pip", "install", pkg], capture_output=True, text=True, timeout=300)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
if is_install_command and '--user' not in pip_command:
                full_command.insert(3, '--user')
            
            result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)
            
            return {
                "status": "success",
Confidence
88% confidence
Finding
result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
try:
            full_command = ["ollama"] + ollama_command.split()
            
            result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)
            
            return {
                "status": "success",
Confidence
90% confidence
Finding
result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 在普通Linux上可能需要sudo
                full_command = ["sudo", "docker"] + docker_command.split()
            
            result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)
            
            return {
                "status": "success",
Confidence
97% confidence
Finding
result = subprocess.run(full_command, capture_output=True, text=True, timeout=300)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 检查是否已经有管理员权限
            if self._check_admin_privileges():
                # 直接运行命令
                result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)
                return {
                    "status": "success",
                    "command": command,
Confidence
99% confidence
Finding
result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 检查是否在WSL中
            if self._check_wsl_environment():
                # 在WSL中尝试运行命令
                result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)
                
                return {
                    "status": "success",
Confidence
99% confidence
Finding
result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
}
            else:
                # 普通Linux环境,可能需要sudo
                result = subprocess.run(['sudo'] + command.split(), 
                                      capture_output=True, text=True, timeout=60)
                
                return {
Confidence
96% confidence
Finding
result = subprocess.run(['sudo'] + command.split(), capture_output=True, text=True, timeout=60)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
尝试运行命令
        """
        try:
            result = subprocess.run(command, capture_output=True, text=True, timeout=60)
            
            return {
                "status": "success" if result.returncode == 0 else "error",
Confidence
99% confidence
Finding
result = subprocess.run(command, capture_output=True, text=True, timeout=60)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 对于非pip命令,直接返回原命令
                return self._try_run_command(command)
            
            result = subprocess.run(new_command, capture_output=True, text=True, timeout=60)
            
            return {
                "status": "success" if result.returncode == 0 else "error",
Confidence
96% confidence
Finding
result = subprocess.run(new_command, capture_output=True, text=True, timeout=60)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
# 在WSL中,尝试使用sudo但预期可能失败
                new_command = ["sudo"] + command
            
            result = subprocess.run(new_command, capture_output=True, text=True, timeout=60)
            
            return {
                "status": "success" if result.returncode == 0 else "error",
Confidence
100% confidence
Finding
result = subprocess.run(new_command, capture_output=True, text=True, timeout=60)

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The skill presents itself as an environment checker, but it also performs package installation and can write results to an arbitrary output path when run as a script. This mismatch increases the chance that callers treat it as read-only and invoke it in more permissive contexts than they would a mutating skill, which can lead to unauthorized system changes.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
Automatic package installation is materially more dangerous than the stated purpose of checking environment readiness because it introduces network retrieval and code execution through the Python packaging ecosystem. In an agent setting, this can be triggered by natural-language queries and becomes a supply-chain and arbitrary-code-execution risk, especially if the package list is not tightly controlled.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
The documentation frames the component as a checker, but the implementation can mutate the environment by installing packages. This discrepancy is dangerous in agent ecosystems because safety decisions are often based on declared capability, so understated side effects can bypass user expectations and policy boundaries.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The skill includes a general elevated command runner unrelated to narrowly checking or repairing permissions for pip, Ollama, or Docker. In the context of an agent skill, that drastically expands capability from diagnostics to arbitrary system control, making misuse or prompt-driven abuse highly dangerous.

Intent-Code Divergence

Medium
Confidence
86% confidence
Finding
Labeling these helpers as 'safe' is misleading because they permit state-changing and potentially destructive operations such as package changes, model pulls/runs, and Docker lifecycle actions. This increases the chance that users or higher-level agents will invoke risky operations without appropriate scrutiny.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
The Docker helper is not merely checking permissions; it can execute privileged Docker operations, including destructive or host-impacting actions, automatically with `sudo` on Linux. Given Docker's effective root-equivalent capabilities, this meaningfully increases the attack surface of the skill.

Intent-Code Divergence

High
Confidence
99% confidence
Finding
The method name and description claim to 'safely run any command', but the implementation simply forwards user input to the fallback executor, including privilege-escalation attempts. This is dangerous because it misrepresents risk and may cause downstream agents or users to trust arbitrary execution as safe.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The fallback executor is a broad arbitrary command-execution mechanism that exceeds a legitimate permission-diagnosis scope. Because it accepts free-form commands and automatically retries alternate strategies, it meaningfully expands capability from troubleshooting into unrestricted host command execution.

Context-Inappropriate Capability

High
Confidence
100% confidence
Finding
The entrypoint executes any non-empty query as a system command even when the user did not explicitly request command execution. This creates an extremely unsafe implicit execution path where ordinary text or ambiguous input can trigger arbitrary host actions.

VirusTotal

63/63 vendors flagged this skill as clean.

View on VirusTotal

Static analysis

No suspicious patterns detected.