Back to skill

Security audit

Agent Task Manager

Security checks for vulnerabilities and agentic risk

Overview

The skill discloses its external API use, but it can turn user or LLM-generated workflow data into outbound notifications and local command execution without enough validation or confirmation.

Review this skill before installing. It requires a SkillBoss API key, sends user and workflow content to an external service, can send outbound notifications, writes local state, and includes an unsafe command wrapper. Use it only in a controlled environment with non-sensitive task text, restricted credentials, trusted recipients, and a reviewed or fixed cooldown script.

Vulnerability Patterns
  • 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
  • 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 (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/cooldown.sh:10
Finding

Arbitrary Command Execution Through Shell eval

Content
View full analysis
"$TIMESTAMP_FILE" echo "✅ Success. Timestamp updated." else echo "❌ Command failed. Timestamp NOT updated." exit 1 fi ``` ### Technical Analysis The wrapper combines all command arguments into a single string with `COMMAND="$@"` and subsequently executes that string through `eval`. This causes shell syntax contained in any argument to be parsed a second time. Consequently, characters such as semicolons, command substitutions, redirections, pipes, and logical operators are interpreted as shell syntax rather than remaining literal command arguments. This is especially dangerous if a caller constructs any part of the wrapped command from task definitions, model output, filenames, URLs, or other untrusted input. Using a shell wrapper to invoke a command is consistent with the declared cooldown functionality, but reparsing the command through `eval` is unnecessary and exceeds the execution behavior needed by that functionality. ### Attack Path 1. An attacker obtains control over an argument passed to `cooldown.sh`, directly or through an application that constructs the wrapped command from untrusted data. 2. The attacker supplies an argument containing shell syntax, for example: ```bash ./scripts/cooldown.sh demo 0 'printf safe; id > /tmp/injected' ``` 3. The script flattens the supplied arguments into `COMMAND`. 4. `eval "$COMMAND"` reparses the injected metacharacters. 5. Both the intended command and the injected command execute. ### Impact Assessment Successful exploitat ...[truncated 544 chars]
Remediation
View remediation
"$TIMESTAMP_FILE" echo "Success. Timestamp updated." else echo "Command failed. Timestamp not updated." exit 1 fi ``` Additional hardening should include: - Never use `eval` for command arguments. - Do not concatenate command arguments into a string. - If only specific programs are expected, enforce an allowlist of executable names. - Ensure callers do not pass model-generated or user-controlled executable names without validation. - Run externally triggered workflows under a dedicated, minimally privileged operating-system account. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/cooldown.sh:17
Finding

Arbitrary File Write Through Unsanitized Cooldown Task Name

Content
View full analysis
"$TIMESTAMP_FILE" ``` ### Technical Analysis `TASK_NAME` is inserted directly into a filesystem path without validation. A task name containing directory separators and `..` components can cause the resolved timestamp path to escape `agent_task_manager_data`. The timestamp filename is also predictable. In a shared or attacker-writable working directory, an attacker may pre-create the expected path as a symbolic link. The final shell redirection follows symbolic links and truncates the linked target before writing the timestamp. Although the appended `_last_run.txt` suffix limits straightforward traversal to target paths with that suffix, a symlink placed at the resulting predictable path can redirect the write to another writable file. ### Attack Path #### Path traversal 1. An attacker controls the first argument passed as `TASK_NAME`. 2. The attacker supplies a name containing traversal components, such as: ```bash ./scripts/cooldown.sh '../../../tmp/attacker' 0 true ``` 3. The script constructs a path equivalent to: ```text ./agent_task_manager_data/../../../tmp/attacker_last_run.txt ``` 4. Once the wrapped command succeeds, the script writes a timestamp outside the intended state directory. #### Symlink overwrite 1. An attacker who can write to the state directory predicts the timestamp filename. 2. The attacker creates that filename as a symbolic link to another ...[truncated 702 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
scripts/task_parser.py:63
Finding

Unvalidated LLM-Generated Workflows Can Trigger Unauthorized Notifications

Content
View full analysis
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
scripts/orchestrator.py:46
Finding

Fabricated Financial Result Used After API Parsing Failure

Content
View full analysis
task_data['threshold_percent'], "whale_percent": whale_percent } ``` ### Technical Analysis When the API returns content that is not valid JSON, the code does not mark the analysis as failed. Instead, it substitutes the fixed value `18.14` and uses that fabricated value to make an alert decision. This fallback conflates test data with a production result. It can be reached because of transient API failures, model formatting errors, upstream changes, or intentionally induced malformed content. Moreover, the LLM prompt contains only a token address and threshold; the implementation does not retrieve authenticated on-chain or market data from an authoritative source before asking the model for a percentage. The resulting value is therefore not a verified measurement and should not control a financial alert. ### Attack Path 1. The financial-analysis request is sent to `/v1/pilot`. 2. The endpoint returns a successful response whose message content is not valid JSON, whether due to a model formatting failure, upstream malfunction, or manipulated response. 3. `json.loads(raw)` raises `JSONDecodeError`. 4. The exception handler silently substitutes `whale_percent = 18.14`. 5. The code compares the fabricated percentage with the workflow threshold. 6. The resulting `alert_triggered` value can cause a notification to be sent or a legitimate alert to be suppressed. 7. The fabricated result is persisted in `task_state.json` as if it were a genuine analysis result. ### Impact Assessme ...[truncated 460 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
Findings (21)

Tainted flow: 'SKILLBOSS_API_KEY' from os.environ (line 10, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Confidence
90% confidence
Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/orchestrator.py (reported line 15)May include surrounding context.

python
def _pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,

Tainted flow: 'SKILLBOSS_API_KEY' from os.environ (line 7, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Confidence
90% confidence
Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · scripts/task_parser.py (reported line 12)May include surrounding context.

python
def _pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding

A second material mismatch exists because the skill claims persistent state, error recovery, and rate-limit management while the documented behavior suggests parsing/generation and remote LLM use without clear implementation of those safeguards. Security-relevant overclaiming is dangerous because users may rely on controls that are absent, leading to unintended data transmission, duplicate actions, or operational failures.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding

A second material mismatch exists because the skill claims persistent state, error recovery, and rate-limit management while the documented behavior suggests parsing/generation and remote LLM use without clear implementation of those safeguards. Security-relevant overclaiming is dangerous because users may rely on controls that are absent, leading to unintended data transmission, duplicate actions, or operational failures.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding

The skill declares sensitive capabilities through behavior and required environment variables but does not define an explicit permission or allowed-tools scope. This can cause the skill to be invoked with broader-than-expected access to network, filesystem, and secrets, reducing operator visibility and increasing the chance of unsafe execution or data exfiltration.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The invocation description is broad enough to match many workflow-related prompts, which can lead to over-triggering of a skill that performs file persistence and external API calls. In this context, accidental activation is more dangerous because the skill also handles secrets and may send data or notifications externally.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The skill description omits important warnings that it persists task state locally and can deliver external notifications via a third-party API. Without clear disclosure, users may provide sensitive workflow data expecting local-only orchestration, while the skill stores or transmits that data beyond the immediate session.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
86% confidence
Finding

The skill explicitly routes AI inference and notification delivery to an external endpoint using a bearer token, creating a clear external transmission path for prompts, task data, and potentially sensitive outputs. In a workflow manager context this is riskier because users may pass internal process details, secrets, or contact information through the orchestration layer without realizing it leaves the local environment.

Content

Scanner excerpt · SKILL.md (reported line 46)May include surrounding context.

md
All AI inference and notification delivery is handled through **SkillBoss API Hub**:

- **Endpoint:** `https://api.heybossai.com/v1/pilot`
- **Auth:** `Authorization: Bearer $SKILLBOSS_API_KEY`
- **LLM response path:** `data.result.choices[0].message.content`

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The script builds a command string from all remaining arguments and executes it with eval, which causes shell parsing and expansion on attacker-controlled input. If any part of COMMAND can be influenced externally, this enables arbitrary command execution, and the workflow/orchestration context makes that especially dangerous because such scripts are designed to run agent-selected actions automatically.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
87% confidence
Finding

The code loads a sensitive API key and sends user/task content to a third-party service, capabilities that are not clearly justified by the stated orchestration-only purpose. In an agent-skill context, undeclared external data flows are risky because they can silently expand trust boundaries and expose user requests or workflow state to outside providers.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
83% confidence
Finding

Accessing a sensitive API key is not inherently unsafe, but doing so without clear disclosure is a security and privacy transparency issue in a user-facing agent skill. Users and deployers may not realize the skill depends on privileged external-service credentials and may process data externally under that account.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
80% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · scripts/orchestrator.py (reported line 15)May include surrounding context.

python
def _pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

The helper sends arbitrary task body content to an external API without any explicit disclosure or consent mechanism. In this skill, that may include user requests, token identifiers, thresholds, recipients, and message bodies, creating a privacy and trust-boundary issue even if the destination is legitimate.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
86% confidence
Finding

The skill claims to be a generic task orchestrator, but the implementation contains domain-specific financial token analysis and outbound notification logic. This scope expansion increases the chance that users invoke sensitive external actions they did not expect from the declared skill purpose, especially when it can trigger real-world notifications based on LLM output.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The notification path can send email/SMS-style messages to external recipients with a default recipient, but there is no visible confirmation, policy check, or warning to the user. In an orchestration skill, silent outbound messaging is dangerous because it can cause unauthorized communications, data leakage, or abuse if upstream inputs are manipulated.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

This parser sends arbitrary user natural-language requests to a third-party LLM service while sourcing credentials from the environment, expanding the skill's data exposure beyond basic task orchestration. If users include secrets, operational details, or sensitive workflow content in requests, that information is transmitted externally without any visible minimization or policy guardrails.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
60% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · scripts/orchestrator.py (reported line 11)May include surrounding context.

python
import requests

SKILLBOSS_API_KEY = os.environ["SKILLBOSS_API_KEY"]
API_BASE = "https://api.heybossai.com/v1"


def _pilot(body: dict) -> dict:

External Transmission

Medium
Category
Data Exfiltration
Confidence
60% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · scripts/task_parser.py (reported line 8)May include surrounding context.

python
import requests

SKILLBOSS_API_KEY = os.environ["SKILLBOSS_API_KEY"]
API_BASE = "https://api.heybossai.com/v1"


def _pilot(body: dict) -> dict:

External Transmission

Medium
Category
Data Exfiltration
Confidence
84% confidence
Finding

The external POST transmits user-provided content to a third-party service, creating a real data-exfiltration surface even if it is part of intended functionality. The danger is context-dependent here: this skill manages multi-step workflows, so requests may contain operational instructions, credentials, endpoints, or business-sensitive details that should not leave the environment by default.

Content

Scanner excerpt · scripts/task_parser.py (reported line 12)May include surrounding context.

python
def _pilot(body: dict) -> dict:
    r = requests.post(
        f"{API_BASE}/pilot",
        headers={"Authorization": f"Bearer {SKILLBOSS_API_KEY}", "Content-Type": "application/json"},
        json=body,

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

The manifest says the skill manages and orchestrates stateful agent workflows, including dependencies, persistence, and rate-limiting. This module instead converts free-form human requests into task definitions and, for unknown inputs, outsources interpretation to an external LLM endpoint, which is behaviorally distinct from orchestration.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The code forwards the full user request to an external LLM endpoint without any user-facing disclosure, consent checkpoint, or sensitivity filtering. In an agent setting, users may reasonably assume task text stays local, so this can cause unintentional leakage of secrets, personal data, or proprietary workflow details.

Content

No source excerpt is available for this finding.