Back to skill

Security audit

Workflow Engine

Security checks for vulnerabilities and agentic risk

Overview

This skill is mostly a queue-orchestration skeleton, but its install instructions ask users to run an unaudited hook installer and enable persistent hooks that the skill says are out of scope.

Review this skill carefully before installing. The queue-orchestration instructions are straightforward, but do not run the workflow-engine installer or enable the listed hooks unless you have independently reviewed the hook implementations, confirmed their source, understand what session data they capture, and know how to disable or remove them.

Vulnerability Patterns
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • 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
Findings (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:66
Finding
Execution of an Unbundled and Unverified Installation Script<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 66-73 **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code ```bash To install the workflow-engine and enable its hooks: ```bash # Clone or navigate to the workflow-engine directory cd workflow-engine # Run the install script to set up hooks ./install-hooks.sh ``` ### Technical Analysis The installation instructions direct users to enter a directory named `workflow-engine` and execute `install-hooks.sh`. Neither that directory nor the script is included in the audited project. The instructions also do not specify a trusted download source, pinned version, cryptographic checksum, or signature. Consequently, the effective installation payload is determined by whichever local directory and script happen to use those names. The script's behavior cannot be verified from the audited package, creating a supply-chain trust gap and an opportunity for directory or script substitution. ### Attack Path 1. An attacker distributes, creates, or replaces a local directory named `workflow-engine`. 2. The attacker places a malicious `install-hooks.sh` file in that directory. 3. A user follows the documented installation instructions and runs `cd workflow-engine`. 4. The user executes `./install-hooks.sh` without any prescribed integrity verification. 5. The malicious script runs with the privileges of that user and can perform any action available to that account. ### Impact Assessment Successful exploitation provides arbitrary command execution under the installing user's account. Depending on that account's privileges, the script could modify files, access user-readable data, alter application configuration, install persistent components, or invoke other local tools. The audited files do not demonstrate automatic privilege escalation, so impact is limited to the permissions held by the user executing the script. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the script-execution instruction if installation is outside this skeleton's intended scope. - If the script is required, include it in the reviewed package so its behavior can be audited. - Specify an authoritative repository URL and pin the dependency to an immutable release or commit. - Publish and require verification of a cryptographic checksum or signed release before execution. - Instruct users to inspect the script before running it. - Execute installation with the minimum necessary privileges and avoid recommending elevated execution. - Document the files, hooks, and configuration changes made by the installer. ]]>

T06 · System Persistence

Warning
Location
SKILL.md:59
Finding
Persistent External Hooks Enabled Despite a Plugin-Free Scope<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 59-79 **Vulnerability Type**: `T06: System Persistence` **Risk Level**: Medium ### Vulnerable Code ```markdown ## Scope Boundary No plugin hooks are implemented in this skeleton. Lifecycle behavior is emulated in-skill to preserve deterministic execution semantics only. ## Installation To install the workflow-engine and enable its hooks: ```bash # Clone or navigate to the workflow-engine directory cd workflow-engine # Run the install script to set up hooks ./install-hooks.sh # Or manually enable hooks via openclaw openclaw hooks enable session-orient openclaw hooks enable write-validate openclaw hooks enable session-capture ``` ``` ### Technical Analysis The scope boundary states that the skill does not implement plugin hooks and only emulates lifecycle behavior. Nevertheless, the installation section instructs users to enable three external hooks: `session-orient`, `write-validate`, and `session-capture`. Hook registration can create behavior that survives the current skill invocation and executes during later session or write lifecycle events. The hook implementations are absent from this project, so their commands, data access, validation behavior, and removal semantics cannot be audited. The `session-capture` name additionally indicates potential processing or persistence of session information, although the audited files do not establish exactly what data it handles. The discrepancy between the declared plugin-free scope and the installation procedure may lead users to enable persistent behavior without sufficient information or informed consent. ### Attack Path 1. An attacker or untrusted package registers implementations under one or more documented hook names. 2. A user follows the installation instructions and enables those hook names through `openclaw`. 3. The hook registrations persist beyond the current workflow invocation. 4. A subsequent session, write, or capture ...[truncated 724 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the hook-enablement commands if hooks are genuinely outside the skill's scope. - If hooks are required, make their installation explicitly optional and require informed user confirmation. - Bundle or link to auditable hook implementations from a pinned, authenticated source. - Document each hook's trigger conditions, commands, data access, storage behavior, and security boundaries. - Verify that hook names resolve to the intended signed or checksummed implementations before enabling them. - Provide commands to list, disable, and completely uninstall every registered hook. - Avoid enabling session-capture functionality by default; require a separate opt-in that explains what session information is collected and retained. - Update the scope statement so it accurately reflects any external components installed by the documented procedure. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (1)

Missing User Warnings

Low
Confidence
93% confidence
Finding
The skill includes shell installation commands (`cd workflow-engine`, `./install-hooks.sh`, and `openclaw hooks enable ...`) that can modify the local environment, but it does not prominently warn users that these commands perform system or workspace changes. In a security-sensitive setting, undocumented environment-modifying commands increase the risk of users running them without understanding trust boundaries, especially since the file otherwise frames itself as a safe skeleton and explicitly discusses hooks being out of scope.

Static analysis

No suspicious patterns detected.