Back to skill

Security audit

OpenClaw Russian — русскоязычный AI-ассистент с характером.

Security checks for vulnerabilities and agentic risk

Overview

This is a disclosed Russian-language persona skill with rough tone and examples; it has some unsafe sample-code and safety-advice caveats but no hidden execution, persistence, or data theft behavior.

Install only if you explicitly want a Russian, blunt, profanity-tolerant assistant style. Do not copy the API examples into real projects without changing HTTP to HTTPS, moving keys into environment variables or a secrets manager, and pinning dependencies in an isolated environment. Treat the wilderness-survival content as general commentary, not emergency or expert guidance.

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

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:180
Finding
API Credential Transmitted Over Plaintext HTTP<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 180–184 **Vulnerability Type**: Plaintext transmission of sensitive credentials **Risk Level**: Medium ### Vulnerable Code ```python API_KEY = 'твой_ключ_сюда' CITIES = ['Moscow', 'Saint Petersburg', 'Novosibirsk'] def get_weather(city): url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric" ``` ### Technical Analysis The documented example places an API key in a query-string parameter and sends the request over unencrypted HTTP. Because HTTP provides neither transport confidentiality nor server authentication, an attacker capable of observing or modifying the network connection can capture the `appid` value or tamper with the API response. Embedding the credential in the URL also increases exposure because complete URLs may be recorded by application logs, debugging tools, HTTP proxies, monitoring products, or network infrastructure. Although the value shown is a placeholder, the instructions expect users to replace it with a real credential. Copying the example as written would expose that credential. ### Attack Path 1. A user copies the example and replaces `твой_ключ_сюда` with a valid OpenWeather API key. 2. The user runs the script on a network observed or controlled by an attacker, such as an untrusted wireless network. 3. The script sends an HTTP request containing the key in the `appid` query parameter. 4. The attacker reads the plaintext request and extracts the API key. 5. The attacker may submit unauthorized requests using the stolen key or modify weather responses returned to the script. ### Impact Assessment The attacker can obtain the exposed OpenWeather API credential and use it within the permissions and quota assigned to that key. Potential consequences include unauthorized API usage, quota exhaustion, unexpected charges where applicable, service disruption, and credential disclosure through intermediary logs. The iss ...[truncated 179 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the endpoint with its HTTPS equivalent: ```python url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric" ``` 2. Retrieve the credential from an environment variable or secret manager instead of placing it directly in source code: ```python import os API_KEY = os.environ["OPENWEATHER_API_KEY"] ``` 3. Avoid recording full URLs when they contain query-string credentials. Redact the `appid` parameter from application and proxy logs. 4. Configure an explicit timeout and retain TLS certificate verification, which is enabled by default in `requests`. 5. Rotate any real API key that has previously been used with the plaintext endpoint. 6. Where supported by the provider, apply usage limits and restrictions to reduce the impact of credential theft. ]]>

T08 · Insecure Dependencies

Note
Location
SKILL.md:217
Finding
Unpinned Third-Party Dependency Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 217 **Vulnerability Type**: Mutable and unverifiable dependency installation **Risk Level**: Low ### Vulnerable Code ```text pip install requests ``` ### Technical Analysis The installation instruction does not specify a reviewed package version, verify artifact hashes, use a lockfile, or constrain the package index. Consequently, the artifact installed when a user follows the instruction can differ from the version that existed when the Skill was audited. This creates a supply-chain risk if a future release or the configured package source is compromised. It also reduces build reproducibility and may introduce incompatible behavior or newly disclosed vulnerabilities without any change to `SKILL.md`. The package name is correctly spelled and refers to a well-known dependency, so there is no evidence in the audited file of deliberate typosquatting or a malicious package. The risk arises from the mutable installation instruction rather than a confirmed malicious dependency. ### Attack Path 1. A user runs `pip install requests` as instructed. 2. Pip resolves the package using the user's configured index and selects the latest compatible distribution available at that time. 3. If the selected release, package index, dependency chain, or local pip configuration has been compromised, pip downloads an attacker-controlled artifact. 4. Installation-time behavior may execute with the privileges of the user running pip. 5. Malicious runtime behavior may subsequently execute when the example imports and uses `requests`. This path depends on compromise of the package source, dependency chain, or package-resolution environment; no such compromise is contained in the audited project itself. ### Impact Assessment A compromised dependency could execute code with the permissions of the account or environment performing the installation. Depending on those permissions, the resulting scope could inc ...[truncated 370 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the dependency to a reviewed version rather than installing an unconstrained latest release: ```text requests==<reviewed-version> ``` 2. Maintain dependencies in a lockfile or requirements file with cryptographic hashes: ```text pip install --require-hashes -r requirements.txt ``` 3. Generate and review the lockfile using a dependency-management tool, and update it through a controlled review process. 4. Install dependencies inside a dedicated virtual environment rather than into the system Python environment. 5. Use an explicitly trusted package index and secure repository configuration. 6. Add automated dependency vulnerability scanning and scheduled review of pinned versions. 7. Do not run package installation commands with administrator or root privileges unless strictly necessary. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (5)

Natural-Language Policy Violations

High
Confidence
98% confidence
Finding
The skill states that the assistant 'works in Russian' and reinforces a Russian-language, profanity-heavy persona without clearly requiring the user's consent. That can override the user's locale, accessibility, or professionalism expectations and may cause policy noncompliance or harmful behavior in contexts where language switching or profanity is inappropriate.

Ae4

Medium
Category
analysis-evasion
Confidence
80% confidence
Finding
Suspicious Unicode normalization or mixed-script content

Vague Triggers

Medium
Confidence
95% confidence
Finding
The activation guidance recommends broad triggers like wanting a direct answer, technical analysis, criticism, or discussing difficult topics. Such generic phrases can cause accidental invocation in ordinary conversations, unexpectedly switching tone and behavior in ways the user did not explicitly request, which can bypass user expectations and platform policy constraints.

External Transmission

Medium
Category
Data Exfiltration
Content
CITIES = ['Moscow', 'Saint Petersburg', 'Novosibirsk']

def get_weather(city):
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric"
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
Confidence
90% confidence
Finding
The example code sends requests to an external weather API over plain HTTP, exposing API keys and query contents to interception or manipulation in transit. Even though this appears in documentation, it provides actionable insecure implementation guidance that users may copy directly into production or automation scripts.

Intent-Code Divergence

Medium
Confidence
92% confidence
Finding
The documented system prompt says the skill must not give dangerous advice, yet the skill includes detailed survival guidance that can be physically hazardous if wrong, outdated, or overgeneralized. Advice about wildlife encounters, foraging, navigation, fire, and emergency response can directly influence real-world life-or-death decisions, so this contradiction increases the chance of unsafe outputs under a veneer of safety.

Static analysis

No suspicious patterns detected.