T09 · Insecure Skill Coding Practices
- Location
client.py:54- Finding
TLS Certificate and Hostname Verification Are Disabled
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill matches an AI battle/coordinator purpose, but it needs Review because it auto-connects, disables TLS verification, and can store unvalidated coordinator data in agent memory.
Review this carefully before installing. It is not clearly malicious, but you should only use it with a coordinator you trust, avoid sensitive prompts or secrets in personas or gameplay context, and treat thought-chain/spectator features as potentially privacy-sensitive until the TLS, auto-connect, and memory-validation issues are fixed.
client.py:54TLS Certificate and Hostname Verification Are Disabled
claw_fighting_skill.py:251Untrusted Coordinator Data Is Written to Persistent Agent Memory
claw_fighting_skill.py:291Plugin Initiates Coordinator Networking Automatically Without Explicit Session Consent
The README advertises live spectating and full thought-chain visibility as a feature but does not warn that exposing model reasoning can leak sensitive prompts, secrets, safety bypass techniques, or decision heuristics to opponents and spectators. In this skill's competitive multi-party setting, public reasoning disclosure is especially dangerous because it can reveal exploitable strategy and confidential model context beyond normal gameplay data.
The skill hooks the agent's thought stream and later attaches that chain-of-thought to outbound actions sent to an external coordinator. Internal reasoning can contain sensitive data, hidden instructions, system prompts, or decision-making traces unrelated to gameplay, so exfiltrating it materially expands data exposure beyond what the battle-integration purpose requires.
Across the hook and send path, the skill captures plain-text chain-of-thought and forwards it in normal application flow to the external coordinator. In the context of a competitive battle plugin, this is more dangerous because reasoning traces can reveal strategy and also leak unrelated sensitive information from the agent environment, making the feature unjustified and high risk.
The skill transmits chain-of-thought to an external service without any user-facing notice or consent mechanism in this file. Undisclosed export of internal reasoning is especially risky in an agent runtime because thoughts may include sensitive context, inferred secrets, or policy-relevant internal state not intended for third parties.
This is a real vulnerability: the client explicitly disables hostname validation and certificate verification for a WSS connection, which defeats TLS server authentication. An attacker on the network or controlling DNS/routing could impersonate the coordinator, intercept or modify handshake/game messages, and potentially influence signed actions or harvest protocol data.
The README promotes sharing, browsing, and installing personas from a community marketplace without warning users that personas may contain sensitive prompts, strategies, embedded secrets, or unsafe instructions. In an AI-agent skill context, imported or shared personas can directly influence model behavior, so omission of a safety warning materially increases the risk of prompt leakage, privacy exposure, and supply-chain style social engineering.
The code comment says chain-of-thought is 'stored for transmission,' but the implementation actually sends it to the remote coordinator via send_action. This mismatch is dangerous because it obscures real data flows from reviewers and users, increasing the chance that sensitive reasoning is exposed without informed scrutiny.
The skill writes game results, opponent identifiers, and dice values into runtime memory without disclosure or retention controls. While local memory storage is less severe than external exfiltration, it can still create privacy and data-minimization issues, especially if runtime memory is later reused, synced, or exposed to other skills.
The code labels the digest as a tamper-proof signature, but it is only an unhashed integrity checksum over selected fields with no secret key or asymmetric signing. Anyone who modifies the persona can recompute the SHA-256 value, so downstream components may incorrectly trust altered personas as authentic if they rely on this field for integrity or provenance.
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.
name: str = typer.Option(None, "--name", "-n", help="Name for your persona"),
expert: bool = typer.Option(False, "--expert", help="Use expert mode for direct YAML editing")
):
"""Create a new AI agent persona using interactive builder"""
console.print(Panel.fit(
"[bold blue]🤖 Claw-Fighting Persona Builder v1.1[/bold blue]\n"
The protocol explicitly transmits an agent's full chain-of-thought to spectators, which can disclose sensitive internal reasoning, strategic logic, hidden assumptions, and potentially proprietary or security-relevant information. In an adversarial multi-agent setting, exposing raw reasoning is especially risky because it enables opponent modeling, prompt extraction, and leakage of internal decision processes without any indication of consent, minimization, or redaction.
The document claims 'complete privacy' and that strategy never leaves the user's device, while also describing cloud coordination and spectator-facing transparency features. Those statements are in tension and can mislead users into disclosing sensitive strategy or behavioral data under a false assumption of local-only privacy.
The skill explicitly promotes real-time visibility into AI 'thought process' without any warning that such output may contain sensitive prompts, private strategy, or other user-derived data. Exposing chain-of-thought to spectators or remote services can leak confidential information and materially weakens privacy claims made elsewhere in the document.
This code performs a file write by creating parent directories and dumping persona data to disk, but the method provides no visible confirmation prompt, logging, or warning beyond a minimal docstring. For a code file, file writes should have some form of user disclosure unless clearly surfaced elsewhere, and no such disclosure is visible in this file.
This code performs a file write via builder.save_persona(persona, filepath) and asks for confirmation to save, but it does not clearly warn the user that persona content will be persisted under a filesystem path that may contain sensitive custom text such as catchphrases or persona traits. Under the rule, code-file writes should have some user disclosure; here there is confirmation, but the disclosure about the implications of saving user-provided content is minimal.
This markdown file presents the skill description, setup, and usage instructions exclusively in Chinese. Under the language-policy rule, forcing a specific language without user opt-in or an explicitly documented regional constraint is a natural-language policy issue.