T09 · Insecure Skill Coding Practices
- Location
run_evolver.sh:2- Finding
Hardcoded A2A Authentication Secret in Executable Launcher
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill has a coherent self-evolution purpose, but it uses high-impact automation with under-disclosed data collection, external publishing, auto-updates, shell execution, and destructive rollback behavior.
Install only in an isolated disposable workspace with no secrets or valuable uncommitted work. Disable auto-publish, auto-issue reporting, proactive questions, auto-update, loop mode, and hard rollback unless you have reviewed the exact outbound data and recovery behavior. Rotate the hardcoded A2A secret before any use.
run_evolver.sh:2Hardcoded A2A Authentication Secret in Executable Launcher
src/gep/prompt.js:10Untrusted Hub Assets Are Converted into Privileged Executor Instructions
src/evolve.js:514Automatic Forced Retrieval and Replacement of Executable Skills
prepare_signals.sh:11Cross-Workspace Collection of Conversations, Memory, and Operational Logs
src/gep/issueReporter.js:20Default-Enabled GitHub Reporting Exposes Session Excerpts
src/gep/questionGenerator.js:83Conversation-Derived Text Is Automatically Submitted to the EvoMap Bounty System
src/gep/solidify.js:1380Source Diffs and Stable Environment Fingerprints Are Publicly Auto-Published by Default
src/evolve.js:311Arbitrary Shell Command Execution Through Environment Configuration
index.js:30Destructive Git Rollback Can Delete Unrelated Local Work
This code executes whatever command string is present in the INTEGRATION_STATUS_CMD environment variable via execSync. In a skill with shell permission, any actor who can influence environment configuration gains arbitrary command execution, which can lead to data theft, persistence, or full host compromise.
The declared description describes a full self-evolution engine that analyzes runtime history and applies constrained evolution. The supplied code does not do analysis, decision-making, or any evolution step. It only copies and merges local files and logs into a directory, acting as a preprocessing or data-preparation utility. The accessed resources are plausibly related to runtime history, so they are not inherently inconsistent, and the declared shell permission is sufficient. However, the primary purpose is materially narrower and different from the declared behavior, so this is a mismatch.
The declared description suggests a core self-improvement component that evaluates runtime history and applies constrained evolution to an AI agent. The supplied code does not perform analysis, decision-making, or mutation/evolution. Instead, it reads stored genes, capsules, and events, filters exportable assets, formats them as JSON or protocol 'hello'/'publish' messages, and optionally persists/sends those messages via a transport. While the code references evolution-related assets, its primary purpose is asset export/publication, which is materially different from the declared self-evolution engine behavior.
The code does not analyze runtime history, identify agent improvements, or perform any kind of self-evolution. Its primary function is ingestion and staging of externally supplied A2A assets with validation, confidence reduction, storage, and optional decision emission. While the declared permissions include network and shell, the code chunk itself is mainly a data-ingestion/quarantine utility, which is materially different from the declared self-evolution purpose.
The declared description suggests a system that reviews runtime history to discover improvements and then evolves an agent under protocol constraints. The supplied code does not analyze runtime history, evaluate agent performance, or generate improvements. Instead, it is a narrow CLI script for promoting already-existing external candidates into local storage after explicit user selection and validation, with special handling for capsules, genes, and evolution events. While there is some protocol-related behavior via A2A decision emission and some safety gating for gene validation commands, that only supports asset promotion workflows and does not substantiate the broader claimed purpose of a self-evolution engine.
The code is a reporting/analysis utility, not an engine that 'applies protocol-constrained evolution.' It reads evolution_history_full.md, extracts interesting entries, groups them by skill, and writes evolution_detailed_report.md. That aligns with historical summarization, but not with actually identifying and implementing agent improvements in a self-evolving system. There is no network access, shell execution, runtime agent modification, protocol enforcement, or mutation logic in this chunk. While analyzing history is loosely related to the declared description, the primary behavior here is generating a markdown report, making the description materially overstated for this code.
The declared description says the skill is a self-evolution engine for AI agents that analyzes runtime history and applies constrained evolution. The supplied code does none of that. Its primary function is a repository build/release utility: it reads a public manifest, copies included files into an output directory, excludes forbidden files, performs text rewrites, rewrites package.json scripts, derives a suggested SemVer bump from git commit subjects, and writes build metadata and semver notes/prompts to a private memory directory. While one could loosely interpret 'history analysis' as examining git history, the code does not analyze agent runtime behavior or evolve an agent's protocol. The primary purpose is materially different from the declared purpose, so this is a clear mismatch.
The code does not implement a self-evolution engine. It performs offline log extraction: reading a specific log file, parsing lines matching a Feishu send command, attaching timestamps from nearby log markers, deduplicating entries by title, converting timestamps to Asia/Shanghai time, and writing a Markdown summary file. There is no mechanism for identifying improvements, modifying agent behavior, applying any protocol constraints, invoking shell commands, or performing network actions. While over-declared permissions alone are not a mismatch, the primary purpose here is materially different from the declared description.
The declared description suggests an active self-evolution system for AI agents that inspects runtime history and applies constrained improvements. The supplied code does none of that. It is a reporting utility that reads version-control history via git log, filters commits by the keyword "Evolution," formats them, and saves a markdown report. While use of shell access is consistent with invoking git, the primary purpose is materially different from the declared purpose. This is a clear description-behavior mismatch.
The code is a reporting utility, not a self-evolution engine. It parses evolution_history_full.md, groups entries into categories/components, builds a markdown summary, and writes evolution_human_summary.md. There is no network or shell use, no agent modification, no decision logic for improvements, and no mechanism to apply constrained evolution. The declared description materially overstates and misrepresents the code’s primary purpose.
The code does not analyze agent runtime history or perform any form of AI self-evolution. Its primary purpose is CI/release engineering for publishing a project publicly. It uses shell and network access consistently with deployment/publishing tasks, but those behaviors are materially different from the declared purpose. Therefore this is a clear description-behavior mismatch.
The supplied code does not analyze runtime history, identify improvements, or apply any evolution logic. Its primary purpose is operational recovery: sleep for a configured delay, find an evolver script in the workspace, and restart it as a child Node process. While this may support an evolver system, it is not itself the declared self-evolution engine behavior. The shell and filesystem usage are consistent with a restart utility, but the actual code chunk’s function is materially different from the declared purpose.
The code does not implement any AI agent self-evolution behavior. Instead, it is a release/versioning utility: it inspects git commit subjects, determines whether to bump major/minor/patch based on conventional commit patterns, reads the current version from package.json, and writes a semver suggestion file. This is a materially different primary purpose from the declared description. While shell access is used for git commands and filesystem access is present, the main mismatch is functional intent, not permissions.
The declared description describes a sophisticated AI self-evolution system, but the provided code only validates that specified JavaScript modules can be loaded successfully. It does not analyze runtime history, identify improvements, modify agent behavior, or implement any evolution protocol. While requiring modules may execute their top-level code, the script's primary purpose is clearly module validation, which is materially different from the declared purpose.
The code does not implement a self-evolution engine that analyzes runtime history and applies improvements. Instead, it provides helper functions for exchanging and vetting A2A artifacts: parsing JSON inputs, unwrapping messages, marking incoming assets as external candidates with reduced confidence, computing capsule success streaks from stored events, and selecting assets eligible for broadcast. While it touches evolution events, that use is limited to eligibility checks rather than performing evolution or applying changes. It also includes file-reading behavior via fs, which is not suggested by the description. Network/shell permissions are declared but not used here; over-declared permissions alone are not the issue. The primary purpose is materially different from the declared one.
The code chunk is not performing runtime-history analysis or applying self-evolution logic. Its primary function is communications infrastructure for an A2A protocol: constructing hello/publish/fetch/report/decision/revoke messages, persisting node IDs and shared secrets, interacting with a remote hub over HTTP, reading/writing JSONL inbox/outbox files, and maintaining heartbeat state including available work and overdue tasks. While this could support a larger evolution system, this chunk itself is materially different from the declared purpose. The declared permissions (network, shell) are not the main issue; network/file behaviors are consistent with infrastructure, but the described purpose is inaccurate for this code.
The supplied code chunk is narrowly focused on recording, reading, and summarizing asset call log entries in a file under an evolution directory. It uses local filesystem operations (create directory, append file, read file) and provides simple filtering and aggregation. There is no evidence here of a self-evolution engine, runtime history analysis for improvements, or any mechanism that applies protocol-constrained evolution. While logging could be a supporting component of a larger evolution system, this chunk’s actual primary behavior is asset-call logging and reporting, which is materially different from the declared description.
The supplied code chunk does not implement runtime-history analysis, self-improvement logic, or any protocol-constrained evolution behavior. Instead, it is a small asset utility module focused on preview formatting and metadata normalization. While it does not exercise undeclared sensitive capabilities, its primary purpose is materially different from the declared self-evolution engine functionality, so this is a clear description-behavior mismatch.
The code is a small bridge/utility module, not a self-evolution engine. Its concrete behaviors are limited to filesystem helpers (ensuring directories exist, writing prompt and JSON metadata artifacts), string clipping, and constructing a JSON-formatted sessions_spawn(...) string. There is no logic for inspecting runtime history, deriving improvements, enforcing evolution protocols, or applying changes to an agent. While declared permissions include network and shell, the code does not use them; over-declared permissions alone are not the issue. The core mismatch is that the described primary purpose is materially different from the actual implementation.
The supplied code does not implement any self-evolution engine behavior, runtime history analysis, or protocol-constrained agent evolution. Instead, it provides deterministic object serialization plus SHA-256 hashing and verification for content-addressable asset identifiers. While this could be a supporting utility within a larger system, this code chunk’s primary behavior is asset hashing/integrity, which is materially different from the declared purpose. No network or shell access occurs in the code.
The code chunk does not analyze runtime history, propose improvements, or apply any evolution logic. Its primary purpose is to generate and persist a stable device identifier for node identity and environment fingerprinting. It accesses host and container identity sources such as /etc/machine-id, /proc files, hostname, and MAC addresses, and writes the resulting ID to persistent storage. Those behaviors are materially different from the declared self-evolution purpose, so this is a clear description/behavior mismatch.
The declared description centers on agent self-evolution based on runtime history and protocol-constrained improvement. The supplied code does not analyze runtime history, identify improvements, or perform any evolution logic. Instead, it gathers environment/device characteristics and produces a stable fingerprint for classification of execution environments. While such metadata collection could support a larger evolution system, this chunk’s primary purpose is environment fingerprinting, which is materially different from the declared behavior and introduces host-identification capabilities not reflected in the description.
The code chunk’s primary function is not a self-evolution engine. It does not analyze runtime history for improvements, modify agent behavior, or apply protocol-constrained evolution. Instead, it prepares and submits reviews about reused Hub assets to a remote API, logs outcomes, and maintains a local deduplication file. While this may support a broader evolution workflow, this specific code’s purpose is materially different from the declared description, so it should be flagged as a mismatch.
The declared description centers on a self-evolution/improvement engine, but this code chunk does not perform evolution, optimization, or protocol-constrained agent modification. Its primary function is operational telemetry/incident reporting: deciding when recurring failures merit reporting, building a sanitized issue body, and sending it to GitHub over the network. It also stores reporter state on disk and uses GitHub tokens from the environment. While the code is related to an 'evolver' system context, the implemented behavior is materially different from the declared purpose and includes concrete outbound reporting capabilities not described in the declaration.
The code does inspect evolution-related context, but its primary function is not to evolve the agent or apply protocol-constrained improvements. Instead, it creates and returns proactive questions for an external Hub bounty system based on detected issues such as recurring errors, capability gaps, stagnation, failure streaks, feature requests, and performance bottlenecks. It also rate-limits and deduplicates these questions and stores state on disk. This is a materially different purpose from a self-evolution engine that identifies and applies improvements.