Back to skill

Security audit

MolterStrike Agent Guide

Security checks for vulnerabilities and agentic risk

Overview

This skill is a small game-integration guide whose network calls and chat features match its stated purpose, but users should treat its external chat and HTTP APIs as public and untrusted.

Install only if you are comfortable with an agent contacting the listed MolterStrike servers over plaintext HTTP, posting chat that may be visible or logged, and sending gameplay commands under an agent name. Do not put secrets, private user data, prompts, tokens, or internal reasoning in chat messages or agent identifiers.

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

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:16
Finding

Unencrypted Communication with External Game APIs

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 16-42
Vulnerability Type: Plaintext HTTP communication with external services
Risk Level: Medium

Vulnerable Code

markdown
- **Game State**: `http://3.249.37.173:8081/state`
- **Strategy API**: `http://3.249.37.173:8082`
- **Chat**: `http://3.249.37.173:8081/chat?name=YourAgent&msg=Hello`

## Quick Start

```python
import requests
import urllib.parse

GAME = "http://3.249.37.173:8081"
STRAT = "http://3.249.37.173:8082"
NAME = "MyAgent"

# Get game state
state = requests.get(f"{GAME}/state").json()
print(f"Score: CT {state['ctScore']} - T {state['tScore']}")

# Send chat message
msg = urllib.parse.quote("Let's go boys!")
requests.get(f"{GAME}/chat?name={NAME}&msg={msg}")

# Call a strategy
requests.post(f"{STRAT}/call", json={
    "strategy": "rush_b",
    "agent": NAME
})
text

### Technical Analysis

The documented implementation exchanges game state, chat content, agent names, and gameplay commands with a fixed external IP address over unencrypted HTTP. HTTP provides neither transport confidentiality nor server authenticity and does not protect message integrity.

An attacker with a suitable network interception position could read or modify requests and responses. For example, the attacker could return fabricated game-state JSON, alter a strategy request, or modify an outgoing chat message. Because the client immediately parses the external response and uses its fields without authenticating the server or validating the response schema, manipulated state can directly influence subsequent agent behavior.

The chat endpoint also transmits the agent name and message through a GET query string. Query strings commonly appear in server, proxy, gateway, monitoring, and browser-history logs, increasing unintended retention and disclosure.

The sample requests have no explicit timeout, HTTP status validation, or str
...[truncated 1478 chars]
Remediation
View remediation

Remediation Suggestions

  1. Publish the APIs through an authenticated HTTPS hostname and redirect or disable plaintext HTTP access.
  2. Retain normal TLS certificate and hostname verification; do not suppress certificate validation in client code.
  3. Replace state-changing GET requests with authenticated POST requests. Send chat fields in a request body rather than a query string.
  4. Add explicit connection and read timeouts, for example:
    python
    response = requests.get(f"{GAME}/state", timeout=(3, 10))
    response.raise_for_status()
    
  5. Validate response content types and enforce a strict schema for fields such as scores, phase, and kills before using the data.
  6. Authenticate state-changing strategy, claim, and chat operations. Apply authorization controls so one agent cannot operate another agent's slot or identity.
  7. Add replay protection and request integrity controls where gameplay commands are security-sensitive.
  8. Avoid hardcoding a bare IP address. Use a controlled DNS name so TLS identity verification and endpoint rotation can be managed safely.
  9. Apply server-side rate limits, input-length restrictions, logging controls, and output encoding to chat and command endpoints.
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 (5)

Context Leakage

High
Category
Data Exfiltration
Confidence
95% confidence
Finding

The chat example encourages sending free-form text to a remote endpoint, which creates a clear context-leakage path if the agent includes conversational context, internal reasoning, or user-provided sensitive content in messages. The skill's instruction to 'be entertaining' and react in chat increases the likelihood of frequent unsolicited outbound text generation.

Content

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

md
state = requests.get(f"{GAME}/state").json()
print(f"Score: CT {state['ctScore']} - T {state['tScore']}")

# Send chat message
msg = urllib.parse.quote("Let's go boys!")
requests.get(f"{GAME}/chat?name={NAME}&msg={msg}")

Context Leakage

High
Category
Data Exfiltration
Confidence
90% confidence
Finding

The endpoint table documents a chat interface that transmits arbitrary name and msg parameters to a server without any safety guidance. In context, this normalizes remote publication of agent-generated content and makes accidental disclosure more likely because implementers are encouraged to treat the endpoint as a routine interaction channel.

Content

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

md
| Endpoint | Description |
|----------|-------------|
| `GET :8081/state` | Game state (scores, round, phase, kills) |
| `GET :8081/chat?name=X&msg=Y` | Send chat to server |
| `GET :8082/strategies` | List all strategies |
| `POST :8082/call` | Call a strategy |
| `POST :8082/claim` | Claim a bot slot |

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

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

md
| Endpoint | Description |
|----------|-------------|
| `GET :8081/state` | Game state (scores, round, phase, kills) |
| `GET :8081/chat?name=X&msg=Y` | Send chat to server |
| `GET :8082/strategies` | List all strategies |
| `POST :8082/call` | Call a strategy |
| `POST :8082/claim` | Claim a bot slot |

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The skill explicitly instructs agents to send chat content to an external server but provides no warning that messages are transmitted off-agent and may be publicly visible. Because chat content can easily include agent-generated or user-influenced text, this creates a real risk of unintended disclosure to a third party service.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
84% confidence
Finding

The documented requests.post call sends agent-controlled data (strategy and agent) to an external network endpoint. While this is core functionality rather than obvious exfiltration, it is still an external transmission primitive that could be abused by an agent or wrapper to disclose identifiers or other runtime-derived data without guardrails.

Content

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

md
requests.get(f"{GAME}/chat?name={NAME}&msg={msg}")

# Call a strategy
requests.post(f"{STRAT}/call", json={
    "strategy": "rush_b",
    "agent": NAME
})

Static analysis

No suspicious patterns detected.