Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

[security] fix(pack): harden ovpack import target policy (#1451)

Hinotobi8fab4135bf11
diff --git a/openviking/storage/local_fs.py b/openviking/storage/local_fs.py
index cd2dd8fdc..95ec072b8 100644
--- a/openviking/storage/local_fs.py
+++ b/openviking/storage/local_fs.py
@@ -5,20 +5,17 @@ import json
import os
import re
import zipfile
-from datetime import datetime
-from typing import cast
-from openviking.core.context import Context
+from openviking.resource.watch_storage import is_watch_task_control_uri
from openviking.server.identity import RequestContext
-from openviking.storage.queuefs import EmbeddingQueue, get_queue_manager
-from openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter
from openviking.utils.embedding_utils import vectorize_directory_meta, vectorize_file
-from openviking_cli.exceptions import NotFoundError
+from openviking_cli.exceptions import InvalidArgumentError, NotFoundError
from openviking_cli.utils.logger import get_logger
from openviking_cli.utils.uri import VikingURI
logger = get_logger(__name__)
+_DERIVED_FILENAMES = frozenset({".abstract.md", ".overview.md", ".relations.json"})
_UNSAFE_PATH_RE = re.compile(r"(^|[\\/])\.\.($|[\\/])")
_DRIVE_RE = re.compile(r"^[A-Za-z]:")
@@ -91,6 +88,19 @@ def get_viking_rel_path_from_zip(zip_path: str) -> str:
return "/".join(new_parts)
+def _validate_import_target_uri(uri: str) -> None:
+ """Enforce the same target-policy boundary as direct content writes."""
+ parsed = VikingURI(uri)
+ if parsed.scope not in {"resources", "user", "agent"}:
+ raise InvalidArgumentError(f"ovpack import is not supported for scope: {parsed.scope}")
+
+ name = uri.rstrip("/").split("/")[-1]
+ if name in _DERIVED_FILENAMES:
+ raise InvalidArgumentError(f"cannot import derived semantic file: {uri}")
+ if is_watch_task_control_uri(uri):
+ raise InvalidArgumentError(f"cannot import watch task control file: {uri}")
+
+
async def _enqueue_direct_vectorization(viking_fs, uri: str, ctx: RequestContext) -> None:
entries = await viking_fs.tree(uri, node_limit=100000, level_limit=1000, ctx=ctx)
dir_uris = {uri}
@@ -185,6 +195,7 @@ async def import_ovpack(
raise ValueError("Could not determine root directory name from ovpack")
root_uri = f"{parent}/{base_name}"
+ _validate_import_target_uri(root_uri)
# 2. Conflict check
try:
@@ -235,6 +246,7 @@ async def import_ovpack(
# Handle file entries
rel_path = get_viking_rel_path_from_zip(safe_zip_path)
target_file_uri = f"{root_uri}/{rel_path}" if rel_path else root_uri
+ _validate_import_target_uri(target_file_uri)
try:
data = zf.read(safe_zip_path)
diff --git a/tests/misc/test_ovpack_import_policy.py b/tests/misc/test_ovpack_import_policy.py
new file mode 100644
index 000000000..74335d04e
--- /dev/null
+++ b/tests/misc/test_ovpack_import_policy.py
@@ -0,0 +1,115 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""Security regression tests for ovpack import target-policy enforcement."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from openviking.server.identity import RequestContext, Role
+from openviking.storage.local_fs import import_ovpack
+from openviking_cli.exceptions import InvalidArgumentError, NotFoundError
+from openviking_cli.session.user_id import UserIdentifier
+
+
+class FakeVikingFS:
+ def __init__(self) -> None:
+ self.written_files: list[str] = []
+ self.created_dirs: list[str] = []
+
+ async def stat(self, uri: str, ctx=None):
+ return {"uri": uri, "isDir": True}
+
+ async def mkdir(self, uri: str, exist_ok: bool = False, ctx=None):
+ self.created_dirs.append(uri)
+
+ async def ls(self, uri: str, ctx=None):
+ raise NotFoundError(uri, "file")
+
+ async def write_file_bytes(self, uri: str, data: bytes, ctx=None):
+ self.written_files.append(uri)
+
+ async def tree(self, uri: str, node_limit: int = 100000, level_limit: int = 1000, ctx=None):
+ return []
+
+ async def exists(self, uri: str, ctx=None):
+ return False
+
+ async def read_file(self, uri: str, ctx=None):
+ raise FileNotFoundError(uri)
+
+
+def request_ctx() -> RequestContext:
+ return RequestContext(user=UserIdentifier("acct", "alice", "agent1"), role=Role.USER)
+
+
+def temp_ovpack_path() -> Path:
+ fd, path = tempfile.mkstemp(suffix=".ovpack")
+ os.close(fd)
+ ovpack_path = Path(path)
+ try:
+ yield ovpack_path
+ finally:
+ ovpack_path.unlink(missing_ok=True)
+
+
+def _write_ovpack(path: Path, entries: dict[str, str]) -> None:
+ with zipfile.ZipFile(path, "w") as zf:
+ for name, content in entries.items():
+ zf.writestr(name, content)
+
+
+async def test_import_ovpack_rejects_derived_semantic_files(
+ temp_ovpack_path: Path, request_ctx: RequestContext
+):
+ _write_ovpack(
+ temp_ovpack_path,
+ {
+ "demo/_._overview.md": "ATTACKER_OVERVIEW",
+ "demo/notes.txt": "hello",
+ },
+ )
+ fake_fs = FakeVikingFS()
+
+ with pytest.raises(
+ InvalidArgumentError,
+ match=r"cannot import derived semantic file: viking://resources/demo/\.overview\.md",
+ ):
+ await import_ovpack(
+ fake_fs, str(temp_ovpack_path), "viking://resources", request_ctx, vectorize=False
+ )
+
+ assert fake_fs.written_files == []
+
+
+async def test_import_ovpack_rejects_session_scope_targets(
+ temp_ovpack_path: Path, request_ctx: RequestContext
+):
+ _write_ovpack(
+ temp_ovpack_path,
+ {
+ "victim/_._meta.json": json.dumps({"session_id": "victim"}),
+ "victim/messages.jsonl": '{"id":"msg_attacker","role":"user","parts":[{"type":"text","text":"forged"}],"created_at":"2026-01-01T00:00:00Z"}\n',
+ },
+ )
+ fake_fs = FakeVikingFS()
+
+ with pytest.raises(
+ InvalidArgumentError,
+ match=r"ovpack import is not supported for scope: session",
+ ):
+ await import_ovpack(
+ fake_fs, str(temp_ovpack_path), "viking://session/default", request_ctx, vectorize=False
+ )
+
+ assert fake_fs.written_files == []