Back to skill

Security audit

Neonous

Security checks for vulnerabilities and agentic risk

Overview

This skill is not clearly malicious, but it gives broad account-management commands that can expose credentials, publish or delete data, and change integrations without enough guardrails.

Install only if you intend to let the agent administer your Neonous account broadly. Verify NEONOUS_URL is the official trusted HTTPS Neonous endpoint before any command, use a scoped and revocable API key if available, prefer the web UI for secrets and billing, and require explicit confirmation before public sharing, deleting, emptying trash, resetting memory, or adding MCP/Telegram integrations.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (3)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:45
Finding
API Credentials Can Be Transmitted to an Unrestricted Environment-Controlled Endpoint<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:45-50` **Vulnerability Type**: Unvalidated destination for credential-bearing network requests **Risk Level**: High ```markdown ## Authentication All API requests require the user's API key: \`\`\` -H "x-api-key: $NEONOUS_API_KEY" \`\`\` Base URL: `$NEONOUS_URL` (e.g., `https://app.neonous-ai.com`). ``` Authenticated requests subsequently combine these variables, for example at `SKILL.md:68-69`: ```bash curl -s "$NEONOUS_URL/custom/builder/agents" \ -H "x-api-key: $NEONOUS_API_KEY" | jq '.[]| {id, name, model, enabled}' ``` ### Technical Analysis The Skill requires `NEONOUS_URL` from the environment and uses it directly as the destination for requests containing `NEONOUS_API_KEY`. It does not instruct the Agent to validate the URL scheme, hostname, port, or origin before transmitting the credential. Authentication over the network is necessary for the declared Neonous platform-management functionality. However, sending a privileged API key to an unrestricted environment-controlled destination exceeds minimum-safe behavior. If `NEONOUS_URL` is accidentally or maliciously set to an HTTP URL or an attacker-controlled HTTPS origin, the API key will be disclosed to that endpoint. The key is used across endpoints that manage agents, conversations, artifacts, workflows, integrations, working memory, and account information, making compromise materially more severe than disclosure of a narrowly scoped read-only token. ### Attack Path 1. An attacker, compromised deployment configuration, or malicious wrapper modifies `NEONOUS_URL`. 2. The value is set to an attacker-controlled endpoint, such as `https://attacker.example`. 3. A user asks the Agent to perform any authenticated Neonous operation. 4. The Agent follows the documented command and sends `x-api-key: $NEONOUS_API_KEY` to the configured endpoint. 5. The attacker records the header and reuses the API key against the legitimate Neonous ser ...[truncated 932 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the unrestricted base URL with the canonical Neonous HTTPS origin where possible. 2. If configurable deployments are required, validate `NEONOUS_URL` before every credential-bearing request: - Require the `https` scheme. - Allowlist approved hostnames and ports. - Reject embedded user information, fragments, and unexpected URL forms. - Reject loopback, link-local, private-network, and metadata-service destinations unless explicitly required and trusted. 3. Do not follow redirects for authenticated requests unless every redirect target is independently allowlisted. 4. Add `curl --fail --show-error --proto '=https'` and appropriate connection and request timeouts. 5. Document that operators must verify the destination before setting `NEONOUS_API_KEY`. 6. Use a narrowly scoped and revocable API key if the Neonous platform supports token scopes. 7. Rotate the API key immediately if it may have been sent to an untrusted destination. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:645
Finding
Telegram Bot Token and Neonous API Key Can Be Posted to an Unvalidated Destination<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:645-648` **Vulnerability Type**: Multiple sensitive credentials transmitted to an unrestricted endpoint **Risk Level**: High ```bash curl -s -X POST "$NEONOUS_URL/custom/builder/telegram/connect" \ -H "x-api-key: $NEONOUS_API_KEY" \ -H "Content-Type: application/json" \ -d '{"agentId": "<AGENT_ID>", "botToken": "<TELEGRAM_BOT_TOKEN>"}' | jq . ``` ### Technical Analysis The Telegram connection example transmits two independent credentials in one request: - `NEONOUS_API_KEY` in the request header. - `TELEGRAM_BOT_TOKEN` in the JSON request body. Submitting a Telegram bot token to the Neonous service is necessary to configure the declared integration. The unsafe behavior is that the destination comes from the unrestricted `NEONOUS_URL` environment variable. The documentation does not require validation that this URL is the official Neonous HTTPS endpoint before either credential is transmitted. This creates a higher-value disclosure scenario than ordinary authenticated API requests because compromise exposes credentials for two separate services. The document recommends the web interface for setup, but it still provides an unsafe API example without a mandatory validation or confirmation step. ### Attack Path 1. An attacker or compromised environment changes `NEONOUS_URL` to an attacker-controlled server. 2. The user requests that an Agent connect a Neonous agent to Telegram. 3. The Agent substitutes the real agent ID and Telegram bot token into the documented request. 4. `curl` sends both the Neonous API key and Telegram bot token to the attacker-controlled server. 5. The attacker reuses the Neonous key to access platform resources. 6. The attacker reuses the Telegram token to impersonate or control the bot within the permissions and capabilities provided by Telegram. ### Impact Assessment Compromise may affect both the Neonous account and the associated Telegram bot. Potential consequ ...[truncated 530 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require the canonical Neonous HTTPS origin or a strict allowlist before accepting or transmitting any Telegram bot token. 2. Prefer the documented Neonous web interface for secret entry and remove the API example if secure destination validation cannot be guaranteed. 3. Require explicit user confirmation immediately before transmitting a Telegram bot token. 4. Avoid printing, logging, or retaining the token in Agent messages, shell history, diagnostic output, or workflow logs. 5. Pass secrets through a protected input mechanism rather than embedding real values directly in reusable command text. 6. Use `curl --fail --show-error --proto '=https'` and do not follow redirects to non-allowlisted origins. 7. Rotate both the Telegram bot token and Neonous API key following suspected disclosure. 8. Review Telegram bot permissions and group access to reduce the impact of token compromise. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:270
Finding
Unpinned MCP Package Can Be Downloaded and Executed Through npx Without Confirmation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:270-281` **Vulnerability Type**: Unpinned third-party dependency execution **Risk Level**: Medium ```bash curl -s -X POST "$NEONOUS_URL/custom/builder/mcp" \ -H "x-api-key: $NEONOUS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "id": "my-mcp", "name": "My MCP Server", "description": "Provides extra tools", "config": { "connectionType": "stdio", "command": "npx", "args": ["-y", "@example/mcp-server"], "envVars": [] } }' | jq . ``` ### Technical Analysis The example registers an MCP server whose command is `npx` with the `-y` option and a package name that has no exact version or integrity constraint. When the configured MCP server is launched, `npx` may retrieve the current package from its configured registry and execute package installation or runtime code. The effective code can therefore change after the Skill has been reviewed. The `-y` option suppresses the normal confirmation prompt, reducing the opportunity for an operator to inspect the selected package and version. Risks include malicious package publication, compromised maintainer accounts, dependency confusion, package-name substitution, and a later malicious release. The shown package is explicitly an example rather than evidence that the named package is malicious. The vulnerability is the unsafe execution pattern users may copy when configuring a real package. ### Attack Path 1. A user or Agent copies the documented MCP configuration and substitutes or retains a package name without pinning an exact version. 2. The Neonous platform later launches the configured stdio MCP server. 3. `npx -y` resolves the package through the configured package registry. 4. A compromised, malicious, or unexpectedly updated package is downloaded. 5. Package lifecycle or runtime code executes in the MCP server's execution environment. 6. The code accesses resources available to that environ ...[truncated 862 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the placeholder with documentation that requires a verified, real package name. 2. Pin packages to an exact reviewed version, for example `package-name@1.2.3`, rather than using an unversioned package. 3. Remove `-y` so that unexpected downloads are not automatically approved. 4. Use lockfiles, integrity hashes, an approved internal registry, or a prebuilt immutable container where the platform supports them. 5. Verify package ownership, publication history, signatures or provenance, and transitive dependencies before enabling the MCP server. 6. Run MCP processes in a sandbox with: - A non-privileged identity. - A read-only filesystem where possible. - No unnecessary environment variables. - Restricted outbound network access. - Explicit resource and execution limits. 7. Require user confirmation before registering, testing, or launching a new MCP package. 8. Periodically review and explicitly approve dependency upgrades instead of automatically resolving the latest release. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (27)

MCP Config Access

High
Category
Agent Snooping
Content
For adding MCP servers, recommend the **web UI** — it has a searchable catalog with one-click install and secure environment variable management.

### List MCP Servers

```bash
curl -s "$NEONOUS_URL/custom/builder/mcp" \
Confidence
86% confidence
Finding
MCP server operations are sensitive because server configurations may expose integration details, endpoints, enabled state, and possibly references to environment-variable-backed secrets. In this skill's context, MCP management extends beyond harmless listing into infrastructure and tool-chain control, making config access more dangerous than ordinary inventory queries.

Description-Behavior Mismatch

Medium
Confidence
98% confidence
Finding
The manifest description materially understates the skill's capabilities. The file exposes operations spanning public sharing, billing visibility, artifact/storage management, reminders, Telegram integration, and memory reset; that scope mismatch can mislead reviewers and users into granting trust or approval under a narrower mental model than the skill actually warrants.

External Transmission

Medium
Category
Data Exfiltration
Content
For complex agents, recommend the web UI — it has AI-assisted generation and a template gallery. For simple agents via API:

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/agents" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
Let Neonous AI generate a full agent config from a name and description:

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/agents/generate" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
Improve existing agent instructions with AI:

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/enhance-instructions" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"instructions": "You help with code"}' | jq '.enhanced'
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
### Update an Agent

```bash
curl -s -X PUT "$NEONOUS_URL/custom/builder/agents/<AGENT_ID>" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
Non-streaming generate endpoint — returns a complete JSON response:

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/chat/generate" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "x-agent-id: <AGENT_ID>" \
  -H "Content-Type: application/json" \
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
Non-streaming generate endpoint — returns a complete JSON response:

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/chat/generate" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "x-agent-id: <AGENT_ID>" \
  -H "Content-Type: application/json" \
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
### Create a Chat Session

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/chat/sessions" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agentId": "<AGENT_ID>", "title": "My Session"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
### Add an MCP Server (stdio)

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/mcp" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
83% confidence
Finding
Adding a stdio MCP server can register and later enable execution of arbitrary external tooling, here exemplified by `npx` fetching a package. In this context, the skill is not merely sending data to Neonous; it is provisioning executable integrations that may expand the platform's trust boundary and introduce supply-chain or command-execution risk if users accept unvetted server definitions.

External Transmission

Medium
Category
Data Exfiltration
Content
### Add an MCP Server (http)

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/mcp" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
80% confidence
Finding
Adding an HTTP MCP server can connect the platform to arbitrary remote endpoints, extending tool access to external infrastructure. This creates a meaningful trust-boundary expansion and possible data egress path beyond routine first-party API use, especially if users are not warned that the configured endpoint may receive agent/tool traffic.

External Transmission

Medium
Category
Data Exfiltration
Content
### Execute a Workflow

```bash
curl -s -X POST "$NEONOUS_URL/custom/builder/workflows/<WORKFLOW_ID>/execute" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"key": "value"}}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
```bash
# Create folder
curl -s -X POST "$NEONOUS_URL/custom/builder/artifacts/folders" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Folder"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Move artifacts to folder
curl -s -X POST "$NEONOUS_URL/custom/builder/artifacts/move" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"artifactIds": ["<ID1>", "<ID2>"], "folderId": "<FOLDER_ID>"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The skill can create public share links for artifacts, which is a data-exposure capability beyond the narrow manifest summary. Because artifacts may contain code, documents, or other sensitive outputs, a public link operation can silently turn private workspace content into externally accessible data if invoked without explicit user understanding.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill documents public sharing, deletion, trash emptying, restore, and duplication actions without requiring user-facing warnings or confirmations. These operations can expose data externally or cause irreversible loss, so omission of impact warnings materially raises the risk of accidental disclosure or destruction during agent-assisted use.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Create space
curl -s -X POST "$NEONOUS_URL/custom/builder/spaces" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "description": "Artifacts for my project", "icon": "📁", "color": "#3B82F6"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
-d '{"name": "My Project", "description": "Artifacts for my project", "icon": "📁", "color": "#3B82F6"}' | jq .

# Update space
curl -s -X PUT "$NEONOUS_URL/custom/builder/spaces/<SPACE_ID>" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Renamed Space"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Add artifact to space
curl -s -X POST "$NEONOUS_URL/custom/builder/spaces/<SPACE_ID>/artifacts" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"artifactId": "<ARTIFACT_ID>"}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Create bookmark
curl -s -X POST "$NEONOUS_URL/custom/builder/bookmarks" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sessionId": "<SESSION_ID>", "messageId": "<MSG_ID>", "tags": ["important"]}' | jq .
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Create reminder (schedule is a cron expression)
curl -s -X POST "$NEONOUS_URL/custom/builder/reminders" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
Telegram bot connection setup introduces an external integration and secret-handling capability that is not reflected in the manifest's stated scope. This broadens the skill from platform management into cross-system account linkage, increasing the chance that users disclose bot tokens or authorize integrations they did not expect this skill to manage.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The Telegram connection flow asks for a bot token and sends it to an external service without prominent handling warnings. Bot tokens are credentials; exposing them in prompts, logs, transcripts, or shell history can enable unauthorized control of the bot and downstream conversations.

External Transmission

Medium
Category
Data Exfiltration
Content
-H "x-api-key: $NEONOUS_API_KEY" | jq .

# Connect agent to Telegram
curl -s -X POST "$NEONOUS_URL/custom/builder/telegram/connect" \
  -H "x-api-key: $NEONOUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agentId": "<AGENT_ID>", "botToken": "<TELEGRAM_BOT_TOKEN>"}' | jq .
Confidence
96% confidence
Finding
This API call transmits a Telegram bot token, which is a credential, to the platform. In context this is more dangerous than ordinary external transmission because it handles sensitive secrets that may be exposed in chat history, logs, examples, or copied commands, enabling takeover of the connected bot if mishandled.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
Working memory reset is a destructive operation affecting retained agent context, but the skill provides no warning about its consequences. A user or agent could erase persistent context unintentionally, disrupting workflows or deleting valuable long-term instructions and memory state.

Static analysis

No suspicious patterns detected.