Back to skill

Security audit

Axiomata Vdv Core

Security checks for vulnerabilities and agentic risk

Overview

This skill is mostly a local text-analysis helper, but it gives broad activation instructions and asks the agent to persist derived patterns in memory without clear user control.

Review before installing. Use this only when you explicitly want VDV-style analysis, avoid running it on confidential text unless you are comfortable with local or agent-memory persistence, and do not allow memory writes or custom storage paths without explicit confirmation and a clear retention/deletion plan.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • 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
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (1)

T02 · Agent Memory Poisoning

Warning
Location
SKILL.md:81
Finding
Untrusted Analysis Patterns May Be Persisted in Agent Memory## Vulnerability Details **File Location**: `SKILL.md:81-87` **Vulnerability Type**: Agent Memory Poisoning **Risk Level**: Medium ### Vulnerable Code Snippet ```text RECORD: - What worked - The pattern of the invariant point found - How to refine future intuition STORE: In your memory system ``` ### Technical Analysis The skill directs the agent to derive a reusable pattern from analyzed content and store it in the agent's memory system. Because the analyzed content may be attacker-controlled, the resulting reinforcement may also reflect attacker-selected claims or instructions. No trust validation, user confirmation, source labeling, namespace isolation, expiration policy, or restriction to task-local state is required before persistence. This creates a trust-boundary violation between untrusted analysis input and trusted long-term agent state. The local Python storage scripts only write JSON files and do not independently modify an agent memory service. Exploitation therefore depends on an agent runtime interpreting and carrying out the instruction in `SKILL.md`. ### Attack Path 1. An attacker supplies crafted text for analysis. 2. The VDV process identifies an attacker-influenced statement as the invariant point or useful pattern. 3. During the reinforcement phase, the agent records that pattern as guidance for future intuition. 4. The instruction `STORE: In your memory system` causes the derived material to be persisted beyond the current task. 5. In later sessions, the agent may retrieve and apply the poisoned pattern when processing unrelated requests. ### Impact Assessment Successful exploitation may contaminate persistent agent state and bias future analysis across sessions. The attacker could influence later reasoning or outputs within the scope in which the stored memory is retrieved. This issue does not directly grant operating-system privileges, code execution, network access, or access-control escalation. Its scope is limited by the ho ...[truncated 119 chars]
Remediation
## Remediation Suggestions 1. Remove the unconditional instruction to store reinforcement in general agent memory. 2. Keep reinforcement in the current response or task-local state by default. 3. Require explicit, informed user confirmation before any persistent write. 4. Treat all patterns derived from analyzed input as untrusted and retain provenance metadata. 5. Store approved records in a skill-specific namespace rather than shared agent memory. 6. Reject records containing behavioral directives, policy overrides, credentials, executable content, or instructions intended to affect unrelated sessions. 7. Apply expiration, review, deletion, and retention limits to persisted records. 8. Ensure the host runtime does not interpret analyzed content as trusted memory instructions.
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (15)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared purpose frames the skill as a truth-analysis methodology, but the commands and architecture include persistent storage and save/load behaviors not disclosed in the main description. This mismatch can mislead operators into sharing sensitive material under the assumption that processing is transient, when results may instead be retained locally.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
### Phase 2: LOGICAL SILENCE — Observe Without Judging
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
## VDV Analysis

**Trigger:** [detected situation]
**Silence:** [observation without judgment]
**Tensions:** [where logic forces]
**Attractor:** [the invariant point]
**Reinforcement:** [pattern for the future]
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
def logical_silence(text: str) -> str:
    """Phase 2: Observe without judging."""
    sentences = re.split(r'[.!?\n]', text)
    sentences = [s.strip() for s in sentences if s.strip()]
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill advertises executable commands that can write data to local storage (`--store` and a `vdv_store.py` component) but declares no explicit tool scope or permissions. This creates an authorization gap where an agent or user may invoke file-writing behavior without clear consent boundaries, increasing the chance of unintended persistence of sensitive analysis output.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The skill is presented as a universal protocol for broad classes of analysis, which makes activation likely in many ordinary contexts. Overbroad activation increases the chance that the skill is applied to sensitive or inappropriate tasks without deliberate user intent, potentially exposing data to its storage or transformation features.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The trigger conditions—contradictions, entropy, complexity, and hidden motivations—are subjective and lack operational boundaries. Ambiguous triggers let the skill self-activate in many conversations, which is risky when the skill also suggests recording results and using persistent storage.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The output and command sections describe recording patterns and storing results locally but do not provide a prominent warning that analysis outputs may persist. Users may supply confidential prompts, believing the skill is ephemeral, when the skill's workflow encourages retention in memory or JSON storage.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The manifest and module docstring present this as a 'VDV loop (5-phase protocol), tension mapping, attractor localization, phi validation' truth-seeking engine, but the code only performs simple keyword/regex heuristics, sentence-length scoring, and a basic sentence-count/length metric for phi. The claimed methodology is materially broader and more rigorous than the actual implementation, creating a semantic mismatch between declared behavior and what the code does.

Dynamic import via __import__()

Medium
Category
Dangerous Code Execution
Content
text = args.input
        
        result = analyze_text(text, args.mode)
        result["timestamp"] = __import__("datetime").datetime.now().isoformat()
        
        if args.store:
            path = store_result(result, args.output_dir)
Confidence
75% confidence
Finding
Dynamic __import__() can load arbitrary modules at runtime, bypassing static analysis and potentially importing malicious code.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The skill manifest describes capabilities like VDV loop analysis, contradiction detection, tension mapping, attractor localization, and phi validation. In contrast, this file's documented and actual behavior is storing arbitrary content to a local JSON file and loading prior entries, which is a storage utility rather than truth-analysis functionality.

Context-Inappropriate Capability

Medium
Confidence
89% confidence
Finding
The script accepts an arbitrary user-controlled path and then reads from and writes to that location without restriction. In an agent or automation context, this can be abused to overwrite accessible files, create files in unintended locations, or read JSON content from arbitrary local paths, expanding the skill beyond its stated purpose and increasing filesystem risk.

Natural-Language Policy Violations

Low
Confidence
80% confidence
Finding
The trigger detection logic embeds specific language keywords in English, French, and Chinese to decide how analysis is performed, but there is no user-configurable language or locale selection. This creates an implicit language policy in the skill behavior rather than offering explicit user opt-in or documented locale constraints.

Intent-Code Divergence

Low
Confidence
97% confidence
Finding
The analyze_text docstring explicitly states that the 'text' argument may be 'Input text or file path', but the function body treats the argument strictly as text and performs no path detection or file reading. File-path handling exists separately in main(), so the function documentation contradicts the function's actual behavior.

Description-Behavior Mismatch

Low
Confidence
84% confidence
Finding
The skill description emphasizes an impersonal universal truth-analysis protocol, while the code includes concrete local file reading via '@filepath' and JSON result storage to disk. Those operational behaviors are not reflected in the manifest description and go beyond the purely analytical framing presented there.

Static analysis

No suspicious patterns detected.