Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
12.9 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""User/agent-level permission publication after session Manager keys were retired.

Session publish/acquire/retain are no-ops. Skill overlays are composed as
temporary ``config=`` at check time, not as derived Manager keys.
"""

import copy

import pytest
from agent_shield.tool_permission import get_permission_manager
from openjiuwen.harness.security.skill_authorization import (
    SkillGrantStore,
    SkillManifest,
    SkillTrustLevel,
    GrantDecision,
)

from jiuwenswarm.agents.harness.common.rails.permissions import config_loader
from jiuwenswarm.agents.harness.common.rails.permissions.published_scopes import (
    PublishedPermissionScopes,
)
from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization_permission_rail import (
    SkillAuthorizationPermissionRail,
)


@pytest.fixture
def publisher():
    store = SkillGrantStore()
    config = {
        "enabled": True,
        "defaults": {"*": "ask"},
        "tools": {"get_current_user": "ask"},
        "skill_authorization": {"enabled": True},
        "net_guard": {"enabled": True, "defaults": "allow"},
    }
    publisher = PublishedPermissionScopes(
        "w3-published-test", base_config=config, store=store
    )
    yield publisher, store, config
    publisher.close()


def activate(store, session, scope="main"):
    manifest = SkillManifest(
        "fixture",
        "test",
        None,
        SkillTrustLevel.OTHER,
        "hash",
        skill_md_hash="markdown-hash",
        overlay={"tools": {"get_current_user": "allow"}},
    )
    store.create_pending_grant(session, scope, manifest, decision=GrantDecision.LOCAL)
    store.activate_pending(session, scope, manifest.skill_name, manifest)


def test_session_publish_apis_are_noop(publisher):
    scopes, _, config = publisher
    manager = get_permission_manager()
    before = set(manager.keys())
    scopes.publish_session("session-one", config)
    scopes.publish_session("session-two", config)
    assert scopes.session_ids() == []
    assert set(manager.keys()) == before
    with pytest.raises(KeyError):
        scopes.key_for("session-one")


@pytest.mark.asyncio
async def test_activation_uses_temp_config_not_manager_skill_key(publisher):
    """Skill activation no longer registers a derived Manager key."""
    from types import SimpleNamespace
    from openjiuwen.harness.security.skill_authorization import get_skill_grant_store

    _, _, config = publisher
    manager = get_permission_manager()
    store = get_skill_grant_store()
    before = set(manager.keys())
    rail = SkillAuthorizationPermissionRail(config=config)
    try:
        activate(store, "session-one")
        rail.set_skill_scope_resolver(lambda _: ("session-one", "main"))
        assert set(manager.keys()) == before | {rail.permission_key}
        ctx = SimpleNamespace(
            agent=object(), session=SimpleNamespace(session_id="session-one")
        )
        temp = rail._temp_permission_config_for_check(ctx)
        assert temp is not None
        assert temp["tools"]["get_current_user"] == "allow"
        assert (
            await manager.check_permission("get_current_user", {}, config=temp)
        ).permission.value == "allow"
        assert (
            await manager.check_permission(
                "get_current_user", {}, rail.permission_key
            )
        ).permission.value == "ask"
        store.invalidate_scope("session-one", "main", reason="test")
        assert set(manager.keys()) == before | {rail.permission_key}
    finally:
        store.clear_session("session-one")
        rail.uninit(None)


def test_session_and_agent_cleanup_do_not_require_session_keys(publisher):
    scopes, store, _ = publisher
    activate(store, "session-one", "child")
    store.clear_session("session-one")
    scopes.close()
    assert scopes.session_ids() == []


def test_unknown_scope_does_not_register_empty_config(publisher):
    scopes, _, _ = publisher
    with pytest.raises(KeyError):
        scopes.key_for("missing-session")
    assert not get_permission_manager().has_config("missing-session")


def test_publish_session_refresh_is_noop_without_manager_churn(publisher, monkeypatch):
    from unittest.mock import Mock

    scopes, store, config = publisher
    activate(store, "session-one")
    manager = get_permission_manager()
    remove = Mock(wraps=manager.remove_config)
    monkeypatch.setattr(manager, "remove_config", remove)
    before = set(manager.keys())
    scopes.publish_session("session-one", config)
    assert set(manager.keys()) == before
    remove.assert_not_called()


def test_netguard_session_delta_merges_and_reverts_without_mutating_base():
    base = {
        "net_guard": {
            "enabled": True,
            "defaults": "allow",
            "urls": {"global.test": "deny"},
            "connection": {"allow_http": False, "allow_private_network": False},
        }
    }
    original = copy.deepcopy(base)
    overlay = {
        "net_guard": {
            "urls": {"session.test": "allow"},
            "connection": {"allow_http": True},
        }
    }
    merged = config_loader._merge_permissions_config(base, overlay)
    assert merged["net_guard"]["urls"] == {
        "global.test": "deny",
        "session.test": "allow",
    }
    assert merged["net_guard"]["connection"] == {
        "allow_http": True,
        "allow_private_network": False,
    }
    assert config_loader._extract_session_overlay(base, merged) == overlay
    assert config_loader._extract_session_overlay(base, original) == {}
    assert base == original


def test_session_policy_write_updates_memory_overlay_only(publisher, monkeypatch):
    scopes, _, config = publisher
    monkeypatch.setattr(config_loader, "is_enterprise", lambda: True)
    monkeypatch.setattr(config_loader, "get_base_permissions_config", lambda: config)
    manager = get_permission_manager()
    before = set(manager.keys())
    try:
        config_loader.persist_permissions_mutate(
            lambda cfg: cfg["net_guard"].update({"urls": {"blocked.test": "deny"}}),
            session_id="session-one",
        )
        assert config_loader.has_session_permissions_overlay("session-one")
        overlay = config_loader._session_overlays["session-one"]
        assert overlay["net_guard"]["urls"] == {"blocked.test": "deny"}
        assert set(manager.keys()) == before
        assert scopes.session_ids() == []
    finally:
        config_loader.clear_session_permissions_overlay("session-one")


@pytest.mark.asyncio
async def test_native_tool_execution_carries_key_and_resets_after_exception_and_cancel():
    import asyncio
    from types import SimpleNamespace
    from flash_sdk import sdk_tools
    from openjiuwen.core.common.security.outbound import outbound_permission_key
    from openjiuwen.core.foundation.tool import LocalFunction, ToolCard
    from openjiuwen.core.foundation.llm.schema.tool_call import ToolCall
    from openjiuwen.harness.rails.security.tool_security_rail import (
        PermissionInterruptRail,
    )

    key = "w3-native-execution"
    config = {
        "enabled": True,
        "defaults": {"*": "allow"},
        "tools": {"outbound_probe": "allow"},
        "net_guard": {"enabled": True},
    }
    rail = PermissionInterruptRail(config=config, permission_key=key)
    started, observed = asyncio.Event(), []

    async def probe(mode):
        observed.append(outbound_permission_key())
        if mode == "cancel":
            started.set()
            await asyncio.Event().wait()
        if mode == "error":
            raise RuntimeError("probe error")
        return "done"

    tool = LocalFunction(
        card=ToolCard(
            name="outbound_probe",
            id="outbound_probe",
            description="probe",
            input_params={"type": "object", "properties": {"mode": {"type": "string"}}},
        ),
        func=probe,
    )
    session = SimpleNamespace(
        session_id="native", get_state=lambda _: None, update_state=lambda _: None
    )
    async with sdk_tools(rail, session, [tool]) as (manager, ctx):
        for mode in ("ok", "error"):
            call = ToolCall(
                id=mode,
                type="function",
                name="outbound_probe",
                arguments='{"mode":"' + mode + '"}',
            )
            await manager.execute(ctx, call, session)
            assert outbound_permission_key() is None
        call = ToolCall(
            id="cancel",
            type="function",
            name="outbound_probe",
            arguments='{"mode":"cancel"}',
        )
        task = asyncio.create_task(manager.execute(ctx, call, session))
        await asyncio.wait_for(started.wait(), 2)
        task.cancel()
        with pytest.raises(asyncio.CancelledError):
            await task
        assert outbound_permission_key() is None
    assert observed == [key, key, key]


def test_file_store_activation_does_not_publish_session_manager_keys(
    tmp_path, monkeypatch
):
    from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization.file_store import (
        FileSkillGrantStore,
    )

    (tmp_path / "session").mkdir()
    store = FileSkillGrantStore(
        sessions_root=lambda: tmp_path, data_root=lambda: tmp_path
    )
    config = {
        "enabled": True,
        "tools": {"get_current_user": "ask"},
        "skill_authorization": {"enabled": True},
    }
    scopes = PublishedPermissionScopes(
        "w3-file-publisher", base_config=config, store=store
    )
    manager = get_permission_manager()
    before = set(manager.keys())
    try:
        scopes.publish_session("session", config)
        activate(store, "session")
        assert set(manager.keys()) == before
        monkeypatch.setattr(
            store, "session_directory", lambda _: tmp_path / "already-deleted"
        )
        store.clear_session("session")
        assert set(manager.keys()) == before
    finally:
        scopes.close()


@pytest.mark.asyncio
async def test_normalized_cache_target_cannot_bypass_netguard(monkeypatch):
    from types import SimpleNamespace
    from unittest.mock import AsyncMock, Mock
    from openjiuwen.core.common.security.outbound import bind_outbound_permission_key
    from openjiuwen.core.common.security.outbound_http import OutboundPermissionError
    from jiuwenswarm.agents.harness.common.tools import web_fetch_tools

    manager = get_permission_manager()
    key = "w3-cache-policy"
    manager.update_config({"enabled": True, "net_guard": {"enabled": True}}, key)
    cache = SimpleNamespace(get=AsyncMock())
    network = Mock(side_effect=AssertionError("must not fetch"))
    monkeypatch.setattr(web_fetch_tools, "_fetch_webpage_sync", network)
    try:
        with bind_outbound_permission_key(key), pytest.raises(OutboundPermissionError):
            await web_fetch_tools._fetch_single_url(
                "127.0.0.1",
                max_chars=100,
                timeout_seconds=1,
                use_cache=True,
                cache=cache,
            )
        cache.get.assert_not_awaited()
        network.assert_not_called()
    finally:
        manager.remove_config(key)


@pytest.mark.asyncio
async def test_jina_secondary_request_uses_current_key_and_cannot_bypass_deny(monkeypatch):
    import asyncio
    import socket
    from types import SimpleNamespace
    import requests
    from openjiuwen.core.common.security.outbound import bind_outbound_permission_key
    from openjiuwen.core.common.security.outbound_http import OutboundPermissionError
    from jiuwenswarm.common import http_proxy_config
    from jiuwenswarm.agents.harness.common.tools import web_fetch_tools

    key, calls = "w3-jina-policy", []
    manager = get_permission_manager()
    manager.update_config({"enabled": True, "net_guard": {"enabled": True, "urls": {"r.jina.ai": "deny"}}}, key)
    monkeypatch.setattr(http_proxy_config, "prepare_requests_kwargs", lambda url, kwargs: dict(kwargs))
    monkeypatch.setattr(http_proxy_config, "resolve_requests_proxies", lambda _: None)
    monkeypatch.setattr(web_fetch_tools, "_apply_free_search_proxy", lambda *args: False)
    # Legacy default must not turn off TLS on the protected route.
    monkeypatch.setattr(web_fetch_tools, "_free_search_ssl_verify", lambda: False)
    monkeypatch.setenv("JIUWENSWARM_ENABLE_JINA_FETCH", "true")
    original_dns = socket.getaddrinfo

    def dns(host, port, *args, **kwargs):
        return original_dns("8.8.8.8" if host == "r.jina.ai" else host, port, *args, **kwargs)

    def primary_response(self, method, url, **kwargs):
        assert kwargs["verify"] is True
        calls.append(url)
        return SimpleNamespace(status_code=403, headers={}, content=b"", url=url)

    monkeypatch.setattr(socket, "getaddrinfo", dns)
    monkeypatch.setattr(requests.Session, "request", primary_response)
    try:
        with bind_outbound_permission_key(key), pytest.raises(OutboundPermissionError):
            await asyncio.to_thread(web_fetch_tools._fetch_webpage_sync, "https://8.8.8.8/", 1)
        assert calls == ["https://8.8.8.8/"]
    finally:
        manager.remove_config(key)