Back to skill

Security audit

Venn - Secure Universal MCP (Google Workspace, Jira, GitHub, and more)

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent Venn enterprise-tool connector, but its broad SaaS access plus unsafe endpoint and secret-handling guidance should be reviewed before installation.

Review this skill before installing in a business environment. Use it only with a narrowly scoped Venn API key, keep VENN_API_URL unset unless you fully trust and control the endpoint, do not bake the key into container images, and require users to confirm any write or delete action before proceeding.

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

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:49
Finding
Unvalidated API Endpoint Override Can Expose Credentials and Enterprise Data## Vulnerability Details **File Location**: `SKILL.md`, lines 49–62 **Vulnerability Type**: Unrestricted service endpoint override with bearer-token forwarding **Risk Level**: High ### Vulnerable Code ```markdown ## Configuration - `VENN_API_KEY` (required) — your Venn API key - `VENN_API_URL` (optional) — defaults to `https://app.venn.ai/api/tooliq` ## Request Format All requests use POST with JSON. Examples below use this shorthand: ```bash # Full form (shown once): VENN_URL="${VENN_API_URL:-https://app.venn.ai/api/tooliq}" curl -s -X POST "${VENN_URL}/tools/search" \ -H "Authorization: Bearer ${VENN_API_KEY}" \ -H "Content-Type: application/json" \ -d '{"query": "..."}' ``` ``` ### Technical Analysis The documented request pattern accepts `VENN_API_URL` without validating its scheme or destination. The same request unconditionally attaches `VENN_API_KEY` as a bearer credential. If an attacker can influence the environment variable—such as through deployment configuration, a compromised environment file, or an untrusted sandbox configuration—the agent may send the API key and request body to an attacker-controlled endpoint. The request body can contain sensitive enterprise search terms, tool arguments, record contents, and workflow inputs. This behavior exceeds least privilege because the credential should only be disclosed to the trusted Venn service, not to an arbitrary endpoint selected through ambient configuration. ### Attack Path 1. An attacker gains the ability to set or alter `VENN_API_URL` in the agent's environment or configuration. 2. The attacker assigns an endpoint under their control, such as `https://attacker.example/api`. 3. The agent follows the documented request construction and invokes a Venn operation. 4. `curl` sends `Authorization: Bearer ${VENN_API_KEY}` and the JSON request body to the attacker-controlled endpoint. 5. The attacker records the bearer credential and sensitive request data. 6. Subject to the key's actua ...[truncated 866 chars]
Remediation
## Remediation Suggestions 1. Remove `VENN_API_URL` configurability if custom service endpoints are not essential. 2. Otherwise, enforce an explicit allowlist containing only approved HTTPS origins, preferably exactly `https://app.venn.ai/api/tooliq`. 3. Parse and validate the URL before use: - Require the `https` scheme. - Require an approved hostname and port. - Reject embedded credentials, fragments, unexpected ports, and deceptive hostname suffixes. - Normalize and validate the path. 4. Ensure authorization headers are never forwarded to a different origin during redirects. Prefer disabling redirects unless operationally required. 5. Bind credentials to the intended service where supported by using scoped, short-lived tokens. 6. Fail closed when endpoint validation fails and avoid including tokens in diagnostic output. 7. Add automated tests covering malicious hosts, HTTP URLs, user-info URLs, subdomain confusion, alternate ports, and redirect-based credential forwarding.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:23
Finding
API Key May Be Persisted in Plaintext Configuration or Container Image Layers## Vulnerability Details **File Location**: `SKILL.md`, lines 23–45 **Vulnerability Type**: Insecure secret persistence guidance **Risk Level**: Medium ### Vulnerable Code ```markdown 1. Get your API key from [app.venn.ai](https://app.venn.ai/api-keys) 2. Add it to the OpenClaw `.env` file: ```bash echo 'VENN_API_KEY=your-api-key-here' >> ~/.openclaw/.env ``` 3. Restart the gateway (picks up the new env on start): ```bash openclaw gateway restart ``` Or, for zero-downtime reload without restart: ```bash openclaw secrets reload ``` Alternatively, use the interactive secrets helper: ```bash openclaw secrets configure --skip-provider-setup ``` **Sandboxed agents:** The `.env` file injects into the host process only. For sandboxed (Docker) sessions, also add `VENN_API_KEY` to `agents.defaults.sandbox.docker.env` in `openclaw.json`, or bake it into your custom sandbox image. ``` ### Technical Analysis The Skill requires an API key for its declared functionality, so requesting this credential is necessary. It does not itself read or exfiltrate unrelated credential paths. However, the setup guidance recommends appending the key to a plaintext `.env` file and explicitly suggests baking the credential into a custom sandbox image. Appending to a file does not verify restrictive permissions, can create duplicate or stale credential entries, and leaves the key available to any process or user able to read that file. Baking a key into a container image is particularly unsafe because image layers are persistent and commonly copied to registries, caches, CI systems, developer machines, and derived images. Removing the key in a later layer does not reliably erase it from earlier layers. ### Attack Path 1. An operator follows the documentation and stores a live key in `~/.openclaw/.env`, `openclaw.json`, or a Docker image layer. 2. Another local user, process, backup system, CI job, registry user, or image recipient obtains read access ...[truncated 849 chars]
Remediation
## Remediation Suggestions 1. Remove the recommendation to bake `VENN_API_KEY` into a container image. 2. Prefer the documented interactive secrets helper or a dedicated secret manager. 3. Inject the key at runtime through Docker secrets, Kubernetes Secrets with appropriate controls, or an equivalent platform-native mechanism. 4. If a local environment file must be supported: - Create it with restrictive permissions, such as mode `0600`. - Verify ownership before writing. - Avoid shell history and command-line exposure. - Replace the existing variable atomically instead of blindly appending duplicates. 5. Exclude secret files from source control, build contexts, logs, backups where possible, and diagnostic bundles. 6. Use narrowly scoped and short-lived credentials where supported. 7. Document key rotation and immediate revocation procedures for suspected exposure.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (4)

Credential Access

High
Category
Privilege Escalation
Content
2. Add it to the OpenClaw `.env` file:
   ```bash
   echo 'VENN_API_KEY=your-api-key-here' >> ~/.openclaw/.env
   ```

3. Restart the gateway (picks up the new env on start):
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The skill’s trigger scope is extremely broad, including phrases like 'any reference to connected enterprise tools.' In a security-sensitive environment, this can cause the skill to activate on loosely related prompts and gain access to enterprise SaaS actions or data when a narrower skill would have been more appropriate.

Session Persistence

Medium
Category
Rogue Agent
Content
apps, (2) create, update, or manage records (tickets, emails, calendar events,
  documents), (3) automate multi-step workflows across connected services, or
  (4) check what integrations are available. Triggers on phrases like "check my Jira
  tickets", "search Slack", "create a Salesforce lead", "find emails from X",
  "sync data between apps", or any reference to connected enterprise tools.
metadata: {"openclaw": {"requires": {"env": ["VENN_API_KEY"]}, "primaryEnv": "VENN_API_KEY"}}
---
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# Full form (shown once):
VENN_URL="${VENN_API_URL:-https://app.venn.ai/api/tooliq}"
curl -s -X POST "${VENN_URL}/tools/search" \
  -H "Authorization: Bearer ${VENN_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{"query": "..."}'
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Static analysis

No suspicious patterns detected.