T01 · Skill Instruction Hijacking
- Location
templates/korean_prompts.py:19- Finding
Embedded Agent Goal Hijacking and Persistent Memory Manipulation Instructions
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This memory and token-saving skill is broadly purpose-aligned, but it has under-disclosed automatic memory indexing, unsafe local persistence, ambiguous install identity, and prompt templates that can steer an agent toward unrelated personal business and health goals.
Review carefully before installing. Do not store secrets, regulated data, private profile files, or agent instructions in this tool unless you accept local duplication and later retrieval. Prefer installing only from a verified, canonical package name and version. Avoid running auto-sync, backup import, or vector-cache functionality until URI path validation, pickle removal, explicit indexing consent, and neutral prompt templates are fixed.
templates/korean_prompts.py:19Embedded Agent Goal Hijacking and Persistent Memory Manipulation Instructions
openviking_korean/vector_store.py:58Arbitrary Code Execution Through Unsafe Pickle Cache Deserialization
openviking_korean/client.py:143Path Traversal Allows JSON Files to Be Written Outside the Context Database
openviking_korean/auto_sync.py:220Automatic Indexing Duplicates Sensitive Agent Memory and Profile Files
SKILL.md:43Conflicting Package Identities Create Dependency-Confusion Risk
The file repeatedly frames the skill as Korean-specific (for example, 'OpenViking Korean', '한국어 Context DB', and '한국어 특화') but does not indicate that users can opt into another language or that the locale restriction is required for a documented compliance or regional purpose. This matches the policy category for language or locale constraints imposed without user choice.
The README encourages saving arbitrary context data and describes automatic loading of stored memories, but it does not warn users that this content may include sensitive prompts, credentials, personal data, or proprietary business information. In an AI-agent context, silent persistence and later retrieval of memory materially increases the risk of unintentional data retention and exposure across tasks, users, or integrations.
The feature list advertises export/import, backup, restore, and migration capabilities without warning that these operations can duplicate, move, or exfiltrate stored context data. For a memory store used by AI agents, portable exports can easily contain sensitive conversational context or internal documents, so undocumented transfer behavior creates a realistic confidentiality risk.
The skill advertises automatic compression, summary-only retrieval, and cleanup behavior as cost-saving features without warning that stored content may be reduced, transformed, or effectively lost for future retrieval. In a memory or persistence skill, this can mislead users into trusting the system with important data and cause integrity or availability loss when summaries replace originals or cleanup routines discard detail.
The skill states that data is automatically loaded on heartbeat/synchronization without any privacy, integrity, or trust-boundary warning. Automatic background loading can expose users to unintended ingestion of stale, sensitive, or tampered data, especially in an agent context where loaded memory may influence later model behavior or decisions.
The module description, function docstring, and imported client are all explicitly Korean-focused, and the user-facing CLI/help text is only in Korean. Under the policy, forcing a specific language without user choice can be a locale/language policy violation unless clearly justified as region-specific.
The function automatically sends the provided query to an external client (OpenVikingKorean.find) without any notice, consent, or indication of where the data goes. Because queries may contain sensitive prompts, credentials, internal project names, or personal data, this creates a real privacy and data-exfiltration risk, especially since the file description indicates this runs automatically at session start.
The benchmark prepends a hard-coded external workspace path to sys.path before importing modules, which changes Python's import resolution and can cause code to be loaded from an unexpected local directory. If that path is writable by another user or contains tampered modules, running the benchmark executes attacker-controlled code, which is unnecessary risk for a benchmarking script.
The file repeatedly frames the skill as Korean-only, including the title 'OpenViking Korean Context' and the statement '한국어 특화' ('specialized for Korean'), but does not indicate that users can choose another language or opt into this locale constraint. This is a natural-language locale policy issue because it imposes a specific language context without documenting user choice or a justified region-specific limitation.
The module title and surrounding natural-language content are presented only in Korean, and the imported client name also suggests a Korean-specific implementation. There is no visible opt-in, alternative language option, or justification that this skill is intentionally limited to a Korean locale.
The document repeatedly describes the product and search behavior as Korean-specific, including 'Korean Context DB for AI Agents' and '한국어 검색', while the rest of the API reference does not offer an explicit language/locale choice or explain that the skill is intentionally region-specific. This can constitute a natural-language locale policy violation when a specific language is imposed without user opt-in or clear justification.
This markdown file describes export(output_path, category) and import_backup(input_path, merge) as backup/restore operations, and later shows backup/restore examples, but it does not include any caution about writing files, restoring data, or possible overwrite/merge effects. Under the markdown criteria for missing user warnings, data-affecting behaviors should disclose risks to user data or system integrity.
The script reads multiple local profile/memory files and sends their full contents into an external client API without any explicit consent prompt, warning, minimization, or trust-boundary check. Because the files appear to contain identity, memory, and agent context data, this can leak sensitive personal or operational information to a remote service or shared backend if the client is not strictly local.
The module persists recent queries, result metadata, and loaded document URIs to a local cache file without any consent, disclosure, or minimization. In this skill's context, queries and retrieved URIs may reflect sensitive user activity, memory contents, or workspace structure, so writing them to disk creates a privacy leak and forensic trail that other local processes or users could read.
The index_workspace function automatically reads MEMORY.md, AGENTS.md, USER.md, and daily memory logs, which can contain sensitive personal or system information. The code comments describe indexing, but there is no user-facing disclosure or warning that these files will be ingested and indexed automatically.
The module description and implementation are explicitly Korean-only, and the default configuration hard-codes the language to "ko". The file does not present any user choice or opt-in mechanism for language/locale selection, which violates the policy against forcing a specific language without opt-in.
The fallback configuration sets "language": "ko" automatically when no config file exists. Because there is no accompanying prompt, option, or documented opt-in for locale selection in this file, the skill imposes a language policy choice by default.
The method is documented as a token-saving compression routine with comments stating it keeps only core information and compresses to 50% or less. In reality, it simply slices the first 500 characters and reports a reduction ratio, which does not guarantee semantic compression or any particular reduction threshold.
This Python file contains user-facing natural-language descriptions, docstrings, and comments exclusively in Korean, starting with the module description and continuing throughout the file. Under the policy, forcing a specific language without user opt-in or a clearly documented justification is a language/locale policy violation.
The module description repeatedly presents the skill as Korean-specific and the implementation is tailored to Korean tokenization and compression behavior, but there is no natural-language opt-in or policy justification for enforcing this locale. Under the stated policy, forcing a specific language or locale without user choice can be a violation.
The top-level documentation presents the skill as achieving major token-cost reduction for Korean NLP. However, the save paths persist not only compressed variants but also the uncompressed original in the 'detail' field, meaning the system retains full text rather than operating solely as a reduced-token representation. This is an active contradiction between the stated behavior and the implemented storage model.
The export_fast method reads all stored JSON contexts and writes them to the caller-supplied output_path, which can copy potentially sensitive stored content to a new location. While there is a failure print on exception, there is no confirmation, user-facing notice before the write, or warning comment/docstring explaining that this operation exports accumulated data.
The module description and user-visible/docstring text are written entirely in Korean, and the model description explicitly emphasizes Korean support, but there is no indication that language choice is configurable or intentionally limited to a Korea-specific context. Under the stated policy, forcing a specific language without user opt-in can be a natural-language policy violation.
The code uses pickle.load() on a cache file from the user's home directory without any integrity verification or format restrictions. Pickle is code-executing by design during deserialization, so if an attacker can replace or tamper with ~/.openviking/vectors/embeddings.pkl, opening the cache can lead to arbitrary code execution in the current user's context.
cache_file = self.cache_dir / "embeddings.pkl"
if cache_file.exists():
with open(cache_file, 'rb') as f:
data = pickle.load(f)
self.documents = data.get('documents', [])
self.embeddings_cache = data.get('embeddings', {})
The comment at L098 says the code is refreshing the embedding for the updated document, but the deletion logic removes self.embeddings_cache[uri]. Elsewhere, embeddings are stored and retrieved by content hash (_get_content_hash(content) at L131 and L201), so this comment-guided intent does not match what the code actually invalidates.
No suspicious patterns detected.