Back to skill

Security audit

Audos – Launch a Startup Via OpenClaw in 10 Minutes

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly matches its Audos workspace-building purpose, but it tells agents to persist non-expiring account tokens and includes helper scripts that can send credentials to an environment-selected API host.

Review this before installing if you are comfortable sending your email, business idea, OTP, and workspace chat content to Audos. Do not let an agent store Audos auth tokens in ordinary memory or plaintext files, and avoid running the helper scripts with a custom AUDOS_BASE_URL unless you fully trust that endpoint.

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 (3)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:39
Finding
Persistent Storage of Non-Expiring Bearer Tokens<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:39-41` and `SKILL.md:312` **Vulnerability Type**: Insecure credential storage guidance **Risk Level**: High ### Vulnerable Code ```markdown - **Token format:** `aud_live_xxxx` (48 hex chars after prefix) - **Auth tokens never expire** — store persistently by email - **Session tokens** expire in 30 min (only needed during OTP flow) ``` The recommendation is repeated later: ```markdown - **Store authTokens** persistently by email — returning users skip OTP entirely ``` ### Technical Analysis The Skill explicitly instructs agents to retain bearer credentials indefinitely and associate them with users' email addresses. It does not require encryption, an operating-system-backed secret manager, access controls, credential rotation, revocation, or automatic deletion. A bearer token grants access based solely on possession. Because the documented tokens never expire, disclosure from agent memory, local state, backups, diagnostic output, or another storage mechanism could permit continuing access until the server explicitly revokes the token. Associating each token with an email address also creates a durable identity-to-credential mapping. ### Attack Path 1. A user completes OTP verification. 2. The Audos API returns an `authToken`. 3. Following the Skill instructions, the agent persistently stores the token under the user's email address. 4. An attacker obtains access to the agent's state, memory, backup, or credential storage. 5. The attacker extracts the non-expiring bearer token. 6. The attacker reuses it against authenticated Audos endpoints, including workspace status, chat, and rebuild operations. ### Impact Assessment A stolen token could allow unauthorized access to the corresponding Audos workspace for an indefinite period. Based on the documented endpoints, the attacker could retrieve workspace and build information, interact with Ott ...[truncated 228 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace non-expiring bearer tokens with short-lived, narrowly scoped access tokens. - Implement refresh-token rotation, explicit revocation, and device or session management. - Store credentials only in an operating-system-backed or platform-provided secret manager. - Never save tokens in conversational memory, plaintext configuration files, logs, shell history, or general-purpose agent state. - Decouple user identifiers such as email addresses from raw credential values where possible. - Define credential retention and secure deletion policies. - Require reauthentication for sensitive operations such as workspace rebuilds. - Document a response procedure for token compromise, including immediate revocation and rotation. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/audos.sh:42
Finding
Caller-Controlled Values Are Embedded into JSON Without Escaping<![CDATA[ ## Vulnerability Details **File Location**: `scripts/audos.sh:42-46` and `scripts/audos.sh:78-80` **Vulnerability Type**: JSON request-body injection **Risk Level**: Medium ### Vulnerable Code ```bash local payload="{\"email\":\"$email\",\"businessIdea\":\"$idea\"" [[ -n "$name" ]] && payload="$payload,\"businessName\":\"$name\"" [[ -n "$target" ]] && payload="$payload,\"targetCustomer\":\"$target\"" payload="$payload}" ``` The same unsafe construction is used for chat requests: ```bash curl -s -X POST "$BASE_URL/chat/$workspace_id" \ -H "Content-Type: application/json" \ -d "{\"authToken\":\"$auth_token\",\"message\":\"$message\"}" ``` ### Technical Analysis Caller-controlled values are concatenated directly into JSON string literals without JSON encoding. Characters such as double quotes, backslashes, newlines, and other control characters can terminate or corrupt the intended JSON value. A crafted value can therefore produce malformed JSON or introduce additional properties into the request body. The shell expansions are enclosed in double quotes, so this code does not directly establish shell command injection. The vulnerability occurs at the JSON serialization boundary: the shell safely passes a string to `curl`, but that string may represent attacker-modified JSON. For example, a business idea containing a closing quote followed by additional JSON syntax could alter the payload structure if the remote endpoint accepts duplicate or unexpected properties. ### Attack Path 1. An attacker supplies a crafted email, business idea, business name, target customer, authentication value, or chat message containing quotation marks and JSON syntax. 2. `audos.sh` concatenates the input into the request body without escaping it. 3. The resulting body is malformed or contains attacker-selected JSON properties. 4. `curl` sends the altered body to the configured Audos API. 5. Depending on serv ...[truncated 518 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Construct every request body with a real JSON serializer instead of string concatenation. For example: ```bash payload="$( jq -n \ --arg email "$email" \ --arg idea "$idea" \ --arg name "$name" \ --arg target "$target" \ '{ email: $email, businessIdea: $idea } + (if $name != "" then {businessName: $name} else {} end) + (if $target != "" then {targetCustomer: $target} else {} end)' )" ``` Use the same approach for chat: ```bash payload="$( jq -n \ --arg token "$auth_token" \ --arg message "$message" \ '{authToken: $token, message: $message}' )" curl -s -X POST "$BASE_URL/chat/$workspace_id" \ -H "Content-Type: application/json" \ --data-binary "$payload" ``` Additionally: - Validate email and OTP formats before submission. - Apply reasonable length limits to business ideas and chat messages. - Reject invalid input locally with a clear error. - Test quotes, backslashes, newlines, Unicode, and control characters. - Prefer placing authentication tokens only in authorization headers rather than request bodies. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/audos.sh:7
Finding
Unrestricted API Base URL Override Can Redirect Credentials<![CDATA[ ## Vulnerability Details **File Location**: `scripts/audos.sh:7` and `scripts/poll-with-updates.sh:14` **Vulnerability Type**: Unvalidated credential destination **Risk Level**: Medium ### Vulnerable Code In `scripts/audos.sh`: ```bash BASE_URL="${AUDOS_BASE_URL:-https://audos.com/api/agent/onboard}" ``` In `scripts/poll-with-updates.sh`: ```bash BASE_URL="${AUDOS_BASE_URL:-https://audos.com/api/agent/onboard}" ``` Sensitive values are subsequently sent to the selected destination, for example: ```bash curl -s -X POST "$BASE_URL/verify" \ -H "Content-Type: application/json" \ -d "{\"sessionToken\":\"$token\",\"otpCode\":\"$code\"}" ``` and: ```bash curl -s -X GET "$BASE_URL/status/$WORKSPACE_ID" \ -H "Authorization: Bearer $AUTH_TOKEN" ``` ### Technical Analysis Both scripts trust the inherited `AUDOS_BASE_URL` environment variable without validating its scheme, hostname, port, or origin. The override controls the destination of requests containing OTP session credentials and long-lived bearer tokens. Environment overrides can be useful for development, but they form a credential-exfiltration channel when inherited from a compromised launcher, shell profile, CI configuration, wrapper script, or execution environment. The code does not require HTTPS and does not restrict the destination to an approved Audos host. ### Attack Path 1. An attacker influences the process environment or convinces a user to run the helper with a malicious `AUDOS_BASE_URL`, such as `https://attacker.example`. 2. The user invokes `verify`, `status`, `chat`, `rebuild`, or the polling helper. 3. The script builds the request URL from the attacker-controlled base URL. 4. Session tokens, OTPs, or bearer tokens are sent to the attacker-controlled server. 5. The attacker captures the credential and replays it against the legitimate Audos API, subject to credential validity and endpoint authoriz ...[truncated 446 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the runtime base URL override from production-facing scripts, or require a deliberate command-line development flag. - Parse and validate the URL before sending any request. - Enforce `https` and allowlist approved hostnames, normally `audos.com`. - Reject embedded user information, unexpected ports, fragments, and malformed URLs. - Separate development and production configurations so test endpoints cannot be selected through an inherited environment variable. - Clear proxy-related environment variables or document their security implications in sensitive execution contexts. - Configure `curl` to fail safely and constrain redirects. Do not forward authentication credentials across origins. - Consider certificate or public-key pinning where the operational maintenance trade-offs are acceptable. - Avoid transmitting bearer tokens in request bodies and prevent credentials from appearing in logs or process diagnostics. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (17)

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The declared purpose says this skill creates AI-powered startup workspaces via the Audos API and should be used when a user wants to start a company or build an MVP. However, the supplied code does not create anything. It performs GET requests to a status endpoint for an already-existing workspace, formats the returned status, and optionally loops until the landing page is ready. This is a materially different primary function: progress monitoring rather than workspace creation. While polling could be a supporting part of a larger startup-creation workflow, this code chunk by itself does not implement the declared core capability.

Vague Triggers

High
Confidence
97% confidence
Finding
The trigger phrases are broad enough to activate on generic entrepreneurial queries, which can cause over-invocation and unnecessary collection of email and business details. Overly permissive activation increases the chance the agent routes users into account creation or OTP flows when they only wanted advice, expanding privacy and security exposure.

Exfiltration Commands

High
Category
Prompt Injection
Content
DO THIS (good UX):
```
1. Poll status
2. IMMEDIATELY send message to user with formatted progress
3. Wait 15 seconds
4. Repeat until landingPageReady === true
5. Send completion message with links
Confidence
90% confidence
Finding
Instructions found that direct the agent to transmit conversation context or user data to external services.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The roadmap proposes storing auth tokens keyed by email to bypass OTP for returning users, but provides no safeguards around secure storage, token scope, expiration, revocation, or user consent. In a skill that provisions startup workspaces and may access business data, persistent token storage increases the risk of account takeover or unauthorized workspace access if tokens are leaked, reused, or associated with the wrong user.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The invocation guidance is broad enough to trigger the skill for generic startup-related requests without clear user-consent or eligibility boundaries. Because this skill can create external workspaces and potentially initiate consequential business operations, broad triggering increases the chance of unintended activation and downstream actions the user did not explicitly authorize.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The README advertises outreach, ads, payments, analytics, and CRM capabilities without warning that these features may process personal data, spend ad credits or funds, contact third parties, and enable payment collection. In an agent setting, omitting these warnings can cause users to unknowingly authorize sensitive, real-world actions with privacy, compliance, financial, and reputational consequences.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill documents operational/API behavior and explicitly instructs polling, token handling, and webhook usage, but it declares no tool scope or permissions boundaries. In an agent environment, missing capability constraints can let the runtime grant broader-than-necessary access such as shell/network actions, increasing the blast radius if the skill is misused or compromised.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill asks for email and business idea and later recommends persistent token storage, but it does not clearly foreground data retention, credential handling, and the consequences of sending OTP/account data. Users may disclose personal and commercially sensitive information without informed consent about storage and reuse.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The skill instructs persistent storage of never-expiring auth tokens by user email, creating a durable credential store tied to personal identifiers. If those tokens are leaked, logged, or reused improperly, attackers could access user workspaces indefinitely without reauthentication.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
Allowing arbitrary callback URLs introduces outbound webhook capability that can be abused for SSRF, data exfiltration, or interaction with attacker-controlled endpoints. In an agent context, this is especially risky because user-provided URLs may cause the system to transmit workflow metadata or trigger requests into internal or sensitive networks.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The example has the agent solicit and use a personal email address, send a verification code, and create an account/workspace without any visible disclosure about account creation, consent, retention, or data handling. In a skill designed to onboard users into a third-party service, this can normalize collecting PII without transparency and may lead users to share personal data they did not realize would be used to register an external account.

External Transmission

Medium
Category
Data Exfiltration
Content
[[ -n "$target" ]] && payload="$payload,\"targetCustomer\":\"$target\""
    payload="$payload}"
    
    curl -s -X POST "$BASE_URL/start" \
        -H "Content-Type: application/json" \
        -d "$payload"
}
Confidence
87% confidence
Finding
This request transmits user-provided email, business idea, and optional business metadata to an external service. While external transmission is expected for this skill's purpose, it is still security-relevant because the skill context involves startup ideas and potentially confidential business information, and the script provides no warning, consent checkpoint, or validation of the destination beyond a mutable environment variable.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The script sends sensitive user data and authentication material (email, business idea, OTP session token, OTP code, auth token, and chat content) to a remote service without any user-facing disclosure, confirmation, or minimization. In an agent-skill context, this can cause users or downstream operators to unknowingly transmit personal and business-sensitive information to an external API, increasing privacy and credential-handling risk.

External Transmission

Medium
Category
Data Exfiltration
Content
[[ -z "$token" || -z "$code" ]] && { echo "Error: sessionToken and otpCode required"; usage; }
    
    curl -s -X POST "$BASE_URL/verify" \
        -H "Content-Type: application/json" \
        -d "{\"sessionToken\":\"$token\",\"otpCode\":\"$code\"}"
}
Confidence
90% confidence
Finding
This call sends a session token and OTP code to a remote endpoint, which are authentication secrets. In the skill context, transmitting login/verification material to an externally configurable base URL is more dangerous than ordinary data submission because a malicious or misconfigured AUDOS_BASE_URL could capture credentials and enable account/session takeover.

External Transmission

Medium
Category
Data Exfiltration
Content
[[ -z "$workspace_id" || -z "$auth_token" || -z "$message" ]] && { echo "Error: workspaceId, authToken, and message required"; usage; }
    
    curl -s -X POST "$BASE_URL/chat/$workspace_id" \
        -H "Content-Type: application/json" \
        -d "{\"authToken\":\"$auth_token\",\"message\":\"$message\"}"
}
Confidence
89% confidence
Finding
This request sends both an auth token and arbitrary chat content to an external service in the request body. Because startup discussions may contain proprietary plans, credentials, or other sensitive material, and because the destination is indirectly controllable via AUDOS_BASE_URL, the combination of bearer-equivalent auth data plus freeform user content creates significant exfiltration risk.

Context-Inappropriate Capability

Low
Confidence
78% confidence
Finding
The manifest emphasizes creating a startup workspace for users starting a business or launching a product. The `/rebuild/:workspaceId` operation modifies an existing remote workspace after creation, which is a lifecycle-management capability not clearly covered by the stated purpose.

Scope Creep

Low
Category
Excessive Agency
Content
> "Audos is creating a branded video to feature on your landing page. This introduces your business to visitors in a compelling way."

### Step 6: Workspace OS
> "Now building your workspace — think of it as your business command center. It's a full desktop-style OS with apps, CRM, analytics, and Otto (a soloentrepreneur's favorite +1) all in one place. You'll manage everything from here."

### Step 7: Landing Page
> "Final stretch — Audos is designing and deploying your landing page. This is what your customers will see first. It's conversion-optimized and ready to collect leads."
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Static analysis

No suspicious patterns detected.