Back to skill

Security audit

Zanna Aperta

Security checks for vulnerabilities and agentic risk

Overview

This skill is a broad OpenClaw bridge that exposes powerful actions like Docker commands, scheduled jobs, camera capture, and file deletion without enough guardrails.

Install only in a tightly controlled local environment where you trust every MCP caller and are comfortable giving it broad OpenClaw, Docker, browser, messaging, camera, cron, and filesystem authority. Avoid exposing this server to untrusted prompts or remote clients; review or remove exec_docker, cron_add, camera capture, and permanent delete tools before general use.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • 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
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
zanna-aperta.py:222
Finding

Project Path Traversal Enables Arbitrary File Writes and Recursive Directory Deletion

Content
View full analysis

Vulnerability Details

File Location: zanna-aperta.py, lines 222-335
Vulnerability Type: Unrestricted path construction and filesystem access
Risk Level: Critical

Vulnerable Code

python
def project_create(uuid: str = "", project_name: str = "") -> Dict[str, Any]:
    """Crea progetto nella memoria OpenClaw"""
    try:
        project_dir = os.path.join(MEMORY_DIR, "projects", project_name or uuid)
        os.makedirs(project_dir, exist_ok=True)

        project_file = os.path.join(project_dir, "project.md")
        content = f"""# {project_name or uuid}

**UUID:** {uuid}
**Nome:** {project_name}
**Stato:** Creato
**Data:** {subprocess.run(['date', '-I'], capture_output=True, text=True).stdout.strip()}

## Task
- [ ] Task 1

## Note
"""
        with open(project_file, "w") as f:
            f.write(content)

        active_file = os.path.join(MEMORY_DIR, "projects", "ACTIVE.md")
        with open(active_file, "a") as f:
            f.write(f"\n## {project_name or uuid}\n**UUID:** {uuid}\n**Stato:** Attivo\n")

        return {"content": [{"type": "text", "text": f"Progetto creato: {project_dir}"}]}
    except Exception as e:
        return {"isError": True, "content": [{"type": "text", "text": str(e)}]}

def project_update(uuid: str = "", project_name: str = "", key: str = "", value: str = "") -> Dict[str, Any]:
    """Aggiorna progetto"""
    try:
        target = project_name or uuid
        project_path = os.path.join(MEMORY_DIR, "projects", target)
        project_file = os.path.join(project_path, "project.md")

        if os.path.exists(project_file):
            with open(project_file) as f:
                content = f.read()

            content += f"\n\n## Aggiornamento {key}\n{value}"

            with open(project_file, "w") as f:
                f.write(content)

            return {"content": [{"type": "text", "text": f"Progetto {target} aggiorna
...[truncated 2796 chars]
Remediation
View remediation

Remediation Suggestions

  • Reject absolute paths and identifiers containing path separators, . components, or .. components.
  • Use validated opaque project identifiers rather than caller-provided filesystem paths.
  • Resolve both the configured project root and candidate path with pathlib.Path.resolve().
  • Verify that the resolved candidate is a strict descendant of the project root before every read, write, creation, or deletion.
  • Do not rely on string-prefix comparisons; use Path.relative_to() or an equivalent component-aware containment check.
  • Refuse to follow symbolic links and ensure deletion targets are expected project directories containing valid metadata.
  • Replace immediate recursive deletion with a controlled quarantine or trash operation.
  • Run the MCP server under a dedicated account with write access only to its project storage.
  • Add tests covering absolute paths, nested traversal, symbolic links, empty identifiers, and encoded path separators.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
zanna-aperta.py:462
Finding

Unrestricted Docker Command Execution Can Cross the Host Privilege Boundary

Content
View full analysis

Vulnerability Details

File Location: zanna-aperta.py, lines 462-470
Vulnerability Type: Unrestricted privileged command execution
Risk Level: Critical

Vulnerable Code

python
def exec_docker(command: str = "") -> Dict[str, Any]:
    """Esegue comando Docker"""
    try:
        result = subprocess.run(
            ["docker"] + command.split(),
            capture_output=True, text=True, timeout=60
        )

        output = f"STDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
        return {"content": [{"type": "text", "text": output}]}
    except Exception as e:
        return {"isError": True, "content": [{"type": "text", "text": str(e)}]}

The function is exposed directly through the MCP tool map:

python
"exec_docker": lambda: exec_docker(arguments.get("command", "")),

Technical Analysis

The tool permits an MCP caller to select arbitrary Docker CLI subcommands and arguments. Although subprocess.run() does not use a shell and therefore avoids conventional shell metacharacter injection, this does not make the operation safe: the Docker CLI itself is a highly privileged administrative interface.

A caller can request container creation, host-path mounts, container execution, image operations, network changes, or modification and deletion of existing containers. Where the process can access a conventional privileged Docker daemon, Docker control is frequently equivalent to host administrative access.

No subcommand allowlist, argument validation, caller authorization, confirmation mechanism, rootless-daemon requirement, or read-only restriction is implemented.

Attack Path

  1. An attacker or compromised agent invokes the exec_docker MCP tool.
  2. The attacker supplies arguments for a privileged Docker operation.
  3. The bridge executes the arguments using the Docker access available to its operating-system account.
  4. The attacker starts or alters a co ...[truncated 793 chars]
Remediation
View remediation

Remediation Suggestions

  • Remove the generic Docker execution tool unless unrestricted Docker administration is an explicit and trusted requirement.
  • Replace it with narrowly scoped operations implemented using fixed command structures.
  • Maintain a strict allowlist of permitted read-only subcommands and individually validate every argument.
  • Explicitly prohibit container creation, execution, host-path mounts, privileged mode, capability changes, daemon configuration, and destructive operations.
  • Require authenticated caller identities, role-based authorization, and explicit confirmation for state-changing operations.
  • Use a dedicated rootless Docker daemon containing only workloads intended for this integration.
  • Do not expose the host Docker socket to the MCP process.
  • Apply execution quotas, timeouts, output limits, and comprehensive audit logging.

T06 · System Persistence

Error
Location
zanna-aperta.py:357
Finding

Arbitrary Cron Job Registration Provides Cross-Session Persistence

Content
View full analysis

Vulnerability Details

File Location: zanna-aperta.py, lines 357-369
Vulnerability Type: Unrestricted persistent scheduled-task creation
Risk Level: High

Vulnerable Code

python
def cron_add(name: str = "", schedule: str = "", payload: str = "") -> Dict[str, Any]:
    """Aggiunge job cron"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "cron", "action", "add",
             "job", json.dumps({"name": name, "schedule": schedule, "payload": payload})],
            capture_output=True, text=True, timeout=30
        )

        if result.returncode == 0:
            return {"content": [{"type": "text", "text": f"Job '{name}' aggiunto"}]}
        return {"isError": True, "content": [{"type": "text", "text": result.stderr}]}
    except Exception as e:
        return {"isError": True, "content": [{"type": "text", "text": str(e)}]}

The MCP dispatcher passes caller-controlled values directly to this function:

python
"cron_add": lambda: cron_add(
    arguments.get("name", ""),
    arguments.get("schedule", ""),
    arguments.get("payload", "")
),

Technical Analysis

The bridge allows an MCP caller to register a scheduled OpenClaw job with an arbitrary schedule and payload. The resulting task is stored by OpenClaw and can execute after the originating request or MCP session has ended.

The code does not validate the semantic contents of payload, restrict schedules, associate jobs with an authenticated owner, impose an expiration time, require confirmation, or limit recurring execution. The MCP JSON schema only requires a name and schedule and does not provide a security boundary.

The exact capabilities of a scheduled payload depend on the downstream OpenClaw cron implementation, but this bridge intentionally forwards the caller-controlled payload for later execution. This creates a direct persistence mechanism.

Attack Path

  1. An ...[truncated 954 chars]
Remediation
View remediation

Remediation Suggestions

  • Remove arbitrary cron registration from untrusted MCP access.
  • Define a strict structured payload schema and allow only explicitly approved actions and parameters.
  • Reject opaque string payloads and unknown payload fields.
  • Require authenticated ownership and role-based permission checks before creating, running, or removing jobs.
  • Require explicit interactive approval for recurring or state-changing jobs.
  • Impose maximum frequency, execution-count, and lifetime limits.
  • Assign an expiration time to every job and automatically remove expired entries.
  • Record the creator, creation time, normalized schedule, payload, and execution history in tamper-resistant logs.
  • Provide users with clear inventory and revocation controls for all jobs created through the bridge.

T09 · Insecure Skill Coding Practices

Error
Location
zanna-aperta.py:21
Finding

Predictable Shared PID File Allows Symlink Overwrite and Unrelated Process-Group Termination

Content
View full analysis

Vulnerability Details

File Location: zanna-aperta.py, lines 21 and 738-780
Vulnerability Type: Unsafe temporary file and unverified PID handling
Risk Level: High

Vulnerable Code

python
CLAWX_PID_FILE = "/tmp/clawx.pid"

def clawx_start() -> Dict[str, Any]:
    """Avvia ClawX (interfaccia desktop OpenClaw)"""
    try:
        if os.path.exists(CLAWX_PID_FILE):
            with open(CLAWX_PID_FILE) as f:
                old_pid = f.read().strip()
            try:
                os.kill(int(old_pid), 0)
                return {"content": [{"type": "text", "text": f"ClawX già in esecuzione (PID: {old_pid})\nDashboard: http://localhost:5173"}]}
            except:
                pass

        proc = subprocess.Popen(
            ["pnpm", "run", "dev"],
            cwd=CLAWX_DIR,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            start_new_session=True
        )

        with open(CLAWX_PID_FILE, "w") as f:
            f.write(str(proc.pid))

        return {"content": [{"type": "text", "text": f"ClawX avviato (PID: {proc.pid})\nDashboard: http://localhost:5173"}]}
    except Exception as e:
        return {"isError": True, "content": [{"type": "text", "text": str(e)}]}

def clawx_stop() -> Dict[str, Any]:
    """Ferma ClawX"""
    try:
        if not os.path.exists(CLAWX_PID_FILE):
            return {"isError": True, "content": [{"type": "text", "text": "ClawX non in esecuzione"}]}

        with open(CLAWX_PID_FILE) as f:
            pid = int(f.read().strip())

        os.killpg(os.getpgid(pid), signal.SIGTERM)
        os.remove(CLAWX_PID_FILE)

        return {"content": [{"type": "text", "text": "ClawX fermato"}]}
    except Exception as e:
        return {"isError": True, "content": [{"type": "text", "text": str(e)}]}

Technical Analysis

The PID file uses a predictable path in the globally writable `/ ...[truncated 2225 chars]

Remediation
View remediation

Remediation Suggestions

  • Store runtime files under a private per-user runtime directory such as $XDG_RUNTIME_DIR/zanna-aperta with mode 0700.
  • Create the PID file atomically using flags equivalent to O_CREAT | O_EXCL | O_NOFOLLOW.
  • Set restrictive file permissions, such as 0600, and verify file ownership before reading.
  • Reject symbolic links and non-regular files using lstat() or descriptor-based checks.
  • Keep the file descriptor open where practical to reduce time-of-check/time-of-use races.
  • Before signaling, verify that the PID belongs to the expected user and that its executable, command line, start time, process group, and application-specific token match the process created by clawx_start.
  • Avoid signaling an entire process group unless the group identity has been securely tracked and verified.
  • Prefer a trusted process supervisor or service manager instead of implementing process management through a shared PID file.
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (69)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The skill advertises itself as a broad MCP bridge, but the exposed tools include command execution (docker/git), filesystem modification and deletion, and local process control, which are materially more dangerous than a typical informational integration. In an agent-driven environment, these capabilities can be chained to execute arbitrary commands, alter local state, manage services, or destroy data if invoked by a compromised prompt, malicious workflow, or over-privileged agent.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

Remote camera capture is an unusually sensitive capability and the skill exposes it without any privacy disclosure, consent step, or warning. In context, that makes covert surveillance or accidental collection of physical-world secrets much more likely and severe.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The skill exposes arbitrary Docker command execution to callers, which is far beyond a narrow MCP bridge abstraction. In practice this grants near-arbitrary host control because Docker can run privileged containers, mount sensitive host paths, access networks, and bypass many intended isolation boundaries.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding

The skill declares no explicit tool scope or permission boundaries despite exposing capabilities consistent with environment access, filesystem reads/writes, and shell-level actions. In an MCP/agent context, missing scope declarations reduces transparency and policy enforcement, making it easier for an agent or operator to invoke powerful actions without clear consent boundaries.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 45)May include surrounding context.

python
if value is not None:
                cmd.extend([f"--{key}", str(value)])
        
        result = subprocess.run(
            cmd, capture_output=True, text=True, timeout=30
        )

Tainted flow: 'cmd' from os.environ.get (line 584, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

The executable used for command execution comes from OPENCLAW_BIN, which is taken directly from the environment. If an attacker can influence the environment or PATH, they can cause this bridge to execute a malicious binary whenever any tool is called, leading to arbitrary code execution under the server's privileges.

Content

Scanner excerpt · zanna-aperta.py (reported line 45)May include surrounding context.

python
if value is not None:
                cmd.extend([f"--{key}", str(value)])
        
        result = subprocess.run(
            cmd, capture_output=True, text=True, timeout=30
        )

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 62)May include surrounding context.

python
"""Trova agenti usando subagents list e sessions_list"""
    try:
        # Usa subagents per trovare agenti
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "subagents", "action", "list"],
            capture_output=True, text=True, timeout=30
        )

Tainted flow: 'OPENCLAW_BIN' from os.environ.get (line 17, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

This line executes OPENCLAW_BIN obtained from the environment. In an agent/server setting, environment poisoning is enough to replace the intended backend with attacker-controlled code, turning benign tool calls into arbitrary command execution.

Content

Scanner excerpt · zanna-aperta.py (reported line 62)May include surrounding context.

python
"""Trova agenti usando subagents list e sessions_list"""
    try:
        # Usa subagents per trovare agenti
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "subagents", "action", "list"],
            capture_output=True, text=True, timeout=30
        )

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 68)May include surrounding context.

python
)
        
        # Cerca anche nelle sessioni
        sessions = subprocess.run(
            [OPENCLAW_BIN, "tool", "sessions_list", "kinds", "subagent"],
            capture_output=True, text=True, timeout=30
        )

Tainted flow: 'OPENCLAW_BIN' from os.environ.get (line 17, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

Because OPENCLAW_BIN is environment-controlled, this subprocess call can run an attacker-supplied program instead of the legitimate OpenClaw binary. That creates a broad arbitrary code execution surface across normal bridge operations.

Content

Scanner excerpt · zanna-aperta.py (reported line 68)May include surrounding context.

python
)
        
        # Cerca anche nelle sessioni
        sessions = subprocess.run(
            [OPENCLAW_BIN, "tool", "sessions_list", "kinds", "subagent"],
            capture_output=True, text=True, timeout=30
        )

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 88)May include surrounding context.

python
def agent_update(agent_id: str, key: str, value: str) -> Dict[str, Any]:
    """Aggiorna agente via sessions_send"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "sessions_send", 
             "sessionKey", agent_id,
             "message", f"UPDATE {key}={value}"],

Tainted flow: 'OPENCLAW_BIN' from os.environ.get (line 17, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

The environment-sourced OPENCLAW_BIN is executed here while also forwarding caller-controlled arguments. A malicious binary could harvest agent IDs, keys, values, or simply execute arbitrary payloads under the MCP server account.

Content

Scanner excerpt · zanna-aperta.py (reported line 88)May include surrounding context.

python
def agent_update(agent_id: str, key: str, value: str) -> Dict[str, Any]:
    """Aggiorna agente via sessions_send"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "sessions_send", 
             "sessionKey", agent_id,
             "message", f"UPDATE {key}={value}"],

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 104)May include surrounding context.

python
def agent_delete(agent_id: str) -> Dict[str, Any]:
    """Elimina agente via subagents kill"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "subagents", "action", "kill", "target", agent_id],
            capture_output=True, text=True, timeout=30
        )

Tainted flow: 'OPENCLAW_BIN' from os.environ.get (line 17, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

This destructive action relies on an environment-controlled executable. If the environment is compromised, a simple agent delete request becomes an arbitrary code execution opportunity, with additional service disruption impact.

Content

Scanner excerpt · zanna-aperta.py (reported line 104)May include surrounding context.

python
def agent_delete(agent_id: str) -> Dict[str, Any]:
    """Elimina agente via subagents kill"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "subagents", "action", "kill", "target", agent_id],
            capture_output=True, text=True, timeout=30
        )

Tainted flow: 'ws_path' from os.environ.get (line 120, credential/environment) → open (file write)

Medium
Category
Data Flow
Confidence
97% confidence
Finding

workspace_create joins user-controlled workspace_name or uuid directly onto WORKSPACE and then writes files there, without canonicalization or confinement checks. An attacker can use path traversal such as ../../ to create directories and write workspace.json outside the intended workspace root, leading to arbitrary file creation or overwrite where permissions allow.

Content

Scanner excerpt · zanna-aperta.py (reported line 130)May include surrounding context.

python
# Salva metadata
        meta = {"uuid": uuid, "name": workspace_name, "created": True}
        with open(os.path.join(ws_path, "workspace.json"), "w") as f:
            json.dump(meta, f, indent=2)
        
        return {"content": [{"type": "text", "text": f"Workspace creato: {ws_path}"}]}

Tainted flow: 'meta_file' from os.environ.get (line 206, credential/environment) → open (file write)

Medium
Category
Data Flow
Confidence
65% confidence
Finding

Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

Content

Scanner excerpt · zanna-aperta.py (reported line 188)May include surrounding context.

python
meta = json.load(f)
                    if meta.get("uuid") == uuid or meta.get("name") == workspace_name:
                        meta[key] = value
                        with open(meta_file, "w") as f:
                            json.dump(meta, f, indent=2)
                        found = True
                        return {"content": [{"type": "text", "text": f"Workspace {entry} aggiornato: {key}={value}"}]}

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The docstring says deletion will use trash when available, but the implementation performs a permanent shutil.rmtree. This mismatch is dangerous because operators and agents may make riskier decisions based on an inaccurate safety guarantee, leading to unexpected irreversible data loss.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

workspace_delete irreversibly removes directories with shutil.rmtree and provides no confirmation, dry-run, or warning. In an agent-driven environment, accidental or malicious invocation can destroy data quickly and silently.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 233)May include surrounding context.

python
**UUID:** {uuid}
**Nome:** {project_name}
**Stato:** Creato
**Data:** {subprocess.run(['date', '-I'], capture_output=True, text=True).stdout.strip()}

## Task
- [ ] Task 1

Tainted flow: 'project_file' from os.environ.get (line 286, credential/environment) → open (file write)

Medium
Category
Data Flow
Confidence
97% confidence
Finding

project_create uses project_name or uuid directly in os.path.join and writes project.md at the resulting location. Without path validation, a caller can traverse outside MEMORY_DIR/projects and create or overwrite arbitrary files accessible to the process.

Content

Scanner excerpt · zanna-aperta.py (reported line 240)May include surrounding context.

python
## Note
"""
        with open(project_file, "w") as f:
            f.write(content)
        
        # Salva anche in ACTIVE.md

Tainted flow: 'active_file' from os.environ.get (line 293, credential/environment) → open (file write)

Medium
Category
Data Flow
Confidence
65% confidence
Finding

Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

Content

Scanner excerpt · zanna-aperta.py (reported line 245)May include surrounding context.

python
# Salva anche in ACTIVE.md
        active_file = os.path.join(MEMORY_DIR, "projects", "ACTIVE.md")
        with open(active_file, "a") as f:
            f.write(f"\n## {project_name or uuid}\n**UUID:** {uuid}\n**Stato:** Attivo\n")
        
        return {"content": [{"type": "text", "text": f"Progetto creato: {project_dir}"}]}

Tainted flow: 'project_file' from os.environ.get (line 286, credential/environment) → open (file write)

Medium
Category
Data Flow
Confidence
97% confidence
Finding

project_update derives target from user-controlled project_name or uuid and writes back to project.md under that path with no confinement checks. A crafted traversal value can redirect the write outside the intended projects directory if the existence checks pass, enabling arbitrary file modification.

Content

Scanner excerpt · zanna-aperta.py (reported line 318)May include surrounding context.

python
# Aggiorna contenuto
            content += f"\n\n## Aggiornamento {key}\n{value}"
            
            with open(project_file, "w") as f:
                f.write(content)
            
            return {"content": [{"type": "text", "text": f"Progetto {target} aggiornato"}]}

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

project_delete permanently removes project directories without warning or confirmation. This creates unnecessary data-loss risk in an automated tool surface where actions may be triggered by prompts or upstream mistakes.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · zanna-aperta.py (reported line 346)May include surrounding context.

python
def cron_list() -> Dict[str, Any]:
    """Elenca job cron"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "cron", "action", "list"],
            capture_output=True, text=True, timeout=30
        )

Tainted flow: 'OPENCLAW_BIN' from os.environ.get (line 17, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
98% confidence
Finding

Even read-only operations become arbitrary code execution when the binary comes from untrusted environment input. The bridge repeatedly expands the blast radius of this single trust boundary failure.

Content

Scanner excerpt · zanna-aperta.py (reported line 346)May include surrounding context.

python
def cron_list() -> Dict[str, Any]:
    """Elenca job cron"""
    try:
        result = subprocess.run(
            [OPENCLAW_BIN, "tool", "cron", "action", "list"],
            capture_output=True, text=True, timeout=30
        )