Back to skill

Security audit

council-blackboard

Security checks for vulnerabilities and agentic risk

Overview

This skill is a plausible multi-model council tool, but it gives broad persistent board and Open WebUI access without enough per-user authorization or disclosure.

Review before installing in any shared Open WebUI or multi-user environment. The skill can create persistent transcripts, store absolute board paths, write directly to the Open WebUI database, launch OpenClaw jobs through user systemd, and route content to the configured OpenClaw model. It should only be used where administrators accept those capabilities and have added board ownership checks, retention/deletion rules, and tightly controlled helper paths.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/openwebui_tool.py:62
Finding

Missing Per-User Authorization for Council Blackboard Operations

Content
View full analysis

Vulnerability Details

File Location: scripts/openwebui_tool.py, lines 62-68
Additional Affected Operations: scripts/openwebui_tool.py, lines 330-580
Vulnerability Type: Broken object-level authorization
Risk Level: High

Vulnerable Code

python
def _board(value: str) -> Path:
    path = Path(value).expanduser().resolve()
    if path.parent != BOARDS or path.suffix.lower() != ".json":
        raise ValueError("invalid council board path")
    if not path.is_file():
        raise FileNotFoundError(f"council board not found: {path}")
    return path

The resulting path is subsequently trusted by operations such as read_council:

python
def read_council(
    self,
    board_path: str,
    full: bool = False,
    recent_per_collection: int = 6,
) -> str:
    """Validate and read either a compact council summary or the full blackboard."""
    try:
        board = _board(board_path)
        if full:
            _bb("validate", str(board))
            return _bb("show", str(board))
        return _bb(
            "summary",
            str(board),
            "--limit",
            str(max(1, min(int(recent_per_collection or 6), 20))),
        )
    except Exception as error:
        return _error(error)

Technical Analysis

The _board validation prevents directory traversal by requiring the resolved file to be directly inside the global council-board directory. However, it does not verify that the authenticated Open WebUI user owns or is authorized to access the selected board.

Only start_council accepts the Open WebUI __user__ context, and it uses that context when creating the room. The methods that read, modify, route, resolve, cancel, or hand over a council do not accept or validate __user__. Consequently, knowledge of a valid board path is treated as sufficient authorization.

The board path is intentionally placed in the coun ...[truncated 2475 chars]

Remediation
View remediation

Remediation Suggestions

  1. Require Open WebUI's authenticated __user__ context on every board operation, not only on start_council.
  2. Persist immutable ownership metadata when creating a board, including the owner user ID and associated chat ID.
  3. Before every read, write, route, cancellation, resolution, or handover, verify that the authenticated user owns the board or has an explicit access-control-list grant.
  4. Do not trust a board path supplied by the model. Prefer an opaque board identifier resolved server-side after authorization.
  5. Bind each board to its Open WebUI chat and reject calls originating from unrelated chats where invocation context is available.
  6. Apply restrictive filesystem permissions and, where practical, use per-user board directories inaccessible to other service users.
  7. Avoid returning absolute filesystem paths to browser-visible chats. Return opaque identifiers or capability tokens with short lifetimes and narrowly scoped permissions.
  8. Add audit logging for the authenticated user, chat, board, operation, route, and authorization outcome.
  9. Add tests proving that one Open WebUI user cannot read, modify, route, cancel, or hand over another user's board, even when the exact path is known.

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/openwebui_tool.py:131
Finding

Weak Timestamp-Based Route Correlation Can Accept Unrelated or Forged Model Entries

Content
View full analysis

Vulnerability Details

File Location: scripts/openwebui_tool.py, lines 131-165
Result Acceptance Location: scripts/openwebui_tool.py, lines 599-611
Vulnerability Type: Improper result correlation and integrity validation
Risk Level: Medium

Vulnerable Code

python
def _fallback_route_results(
    board: Path,
    route_id: str,
    route_created_at: str | None,
) -> list[dict[str, Any]]:
    """Correlate old/uncooperative agents without accepting stale old replies."""
    created = _parse_timestamp(route_created_at)
    if created is None:
        return []
    raw = _bb_json("show", str(board))
    output: list[dict[str, Any]] = []
    for collection in RESULT_COLLECTIONS:
        for entry in raw.get(collection, []):
            writer = (entry.get("written_by") or {}).get("model", "")
            timestamp = _parse_timestamp(entry.get("created_at"))
            tagged = (entry.get("metadata") or {}).get("route_id") == route_id or any(
                isinstance(item, dict) and item.get("route_id") == route_id
                for item in entry.get("provenance", [])
            )
            if tagged:
                continue
            if (
                str(writer).startswith(OPENCLAW_WRITER_PREFIX)
                and timestamp is not None
                and timestamp >= created
            ):
                output.append(
                    {
                        "collection": collection,
                        **entry,
                        "correlation": "writer_and_timestamp_fallback",
                    }
                )
    output.sort(key=lambda item: item.get("created_at", ""))
    return output

The fallback is used when no properly tagged route result exists:

python
tagged = _route_results(board, route_id).get("results", [])
results = [
    item
    for item in tagged
    if str((item.get("written_
...[truncated 3358 chars]
Remediation
View remediation

Remediation Suggestions

  1. Remove writer_and_timestamp_fallback and require an exact route_id match for every accepted route result.
  2. If a model fails to attach the required route ID, mark the route as failed or leave it pending with an explicit protocol-error message; do not infer correlation.
  3. Bind each result to the route claim, expected systemd unit, session key, and authenticated writer identity.
  4. Treat the model name as descriptive metadata rather than proof of origin. Use a trusted server-side identity or signed receipt generated by the route executor.
  5. Verify that all result entry IDs were created after the claim and are explicitly associated with the same route before resolution.
  6. Reject entries associated with another route rather than considering them fallback candidates.
  7. Record protocol violations separately so operators can diagnose uncooperative agents without weakening result integrity.
  8. Add tests involving delayed results, overlapping sessions, forged writer names, untagged entries, and entries carrying another route ID.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
Findings (19)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The declared description presents a collaboration/blackboard skill, but the detected behavior includes launching external agents, managing async route state, interacting with systemd, and executing environment-selected helpers. This mismatch is dangerous because reviewers and users may approve the skill expecting a benign coordination feature while it actually has broad process-control and execution capabilities.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
91% confidence
Finding

The skill advertises orchestration behavior but does not declare any explicit tool scope or permissions despite requiring shell and environment access. This weakens policy enforcement and user/operator visibility, increasing the chance that the skill can invoke powerful local capabilities without adequate review or least-privilege constraints.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The invocation text says to use the skill whenever the user asks models to 'confer, compare approaches, review one another, or form a multi-model council.' Several of these phrases are broad and could match ordinary requests for comparison or review without clearly distinguishing when this skill should or should not activate.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
90% confidence
Finding

The skill explicitly creates a fresh board and visible room for each council and treats the JSON board as an auditable source of truth, which establishes session persistence beyond the immediate interaction. Persistent records increase the risk of sensitive data retention, cross-session leakage, and later unauthorized access if storage, access control, or sharing boundaries are weak.

Content

Scanner excerpt · SKILL.md (reported line 12)May include surrounding context.

md
## Rules

1. Create a fresh board and Open WebUI room for every new council:
   `python skills/council-blackboard/scripts/council.py room --topic "..." --user-id USER_ID`
2. Give the user the returned `chat_url` immediately. The WebUI room is the visible transcript; the JSON board is the auditable source of truth.
3. Validate before every hop. Read the goal, typed entries, revision, next capability, and unresolved questions.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The rules instruct creation of a visible WebUI transcript and auditable JSON board, but the skill description does not clearly warn users that their content will be persisted in shared/visible records. This can lead to unintended disclosure of sensitive prompts, internal reasoning artifacts, identifiers, or operational data during normal use.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
82% confidence
Finding

The manifest frames the skill as providing visible council rooms with typed blackboards and session handovers, but this file also launches another script via subprocess using interpreter and path values influenced by environment variables. Spawning external commands is a stronger capability than the stated room/blackboard semantics alone justify, especially since the manifest does not mention command execution as part of scope.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/council.py (reported line 56)May include surrounding context.

python
def run_command(command: list[str], timeout: int = 60) -> str:
    try:
        process = subprocess.run(
            command,
            text=True,
            capture_output=True,

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 73)May include surrounding context.

python
def run_command(command: list[str], timeout: int = 60) -> str:
    try:
        process = subprocess.run(
            command,
            text=True,
            capture_output=True,

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The script directly writes chat and message records into the Open WebUI SQLite database instead of using a supported application API. This bypasses normal application-layer validation, authorization, audit controls, and schema safety guarantees, so a caller who can invoke the tool can create content as an arbitrary user_id and potentially corrupt or spoof application state.

Content

No source excerpt is available for this finding.

Tainted flow: 'command' from os.environ.get (line 203, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
85% confidence
Finding

The _run wrapper executes command vectors built elsewhere from environment-controlled binary paths such as COUNCIL_SYSTEMD_RUN, COUNCIL_OPENCLAW_BIN, COUNCIL_SYSTEMCTL, and COUNCIL_PYTHON. That creates a broad arbitrary-executable trust boundary: anyone able to set those variables can redirect the tool to run attacker-chosen binaries.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 73)May include surrounding context.

python
def _run(command: list[str], timeout: int = 120) -> str:
    try:
        process = subprocess.run(
            command,
            text=True,
            capture_output=True,

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

The skill goes beyond simple council/blackboard collaboration by launching external executables and user systemd transient services to run OpenClaw asynchronously. This expands the attack surface substantially: the tool can spawn local processes, persist work outside the immediate request lifecycle, and interact with local system service management, which is more dangerous in an LLM tool context than its description suggests.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The code forwards the board path, route ID, and routed question to an OpenClaw agent configured with OPENCLAW_MODEL, defaulting to an external OpenAI model, without any user-facing consent or data-classification guard in this file. In a collaboration tool, routed questions and board content can easily contain sensitive internal data, so silent transmission to an external model creates a real confidentiality risk.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 236)May include surrounding context.

python
systemctl = os.environ.get("COUNCIL_SYSTEMCTL") or shutil.which("systemctl")
    if not systemctl:
        return {"available": False, "reason": "systemctl not found"}
    process = subprocess.run(
        [
            systemctl,
            "--user",

Tainted flow: 'systemctl' from os.environ.get (line 233, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
88% confidence
Finding

The code allows COUNCIL_SYSTEMCTL from the environment to determine which executable is launched for status checks. In a hostile or multi-tenant deployment, an attacker who can influence the environment can replace systemctl with an arbitrary program and gain code execution in the Open WebUI process context.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 236)May include surrounding context.

python
systemctl = os.environ.get("COUNCIL_SYSTEMCTL") or shutil.which("systemctl")
    if not systemctl:
        return {"available": False, "reason": "systemctl not found"}
    process = subprocess.run(
        [
            systemctl,
            "--user",

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
70% confidence
Finding

subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 748)May include surrounding context.

python
unit = (status.get("claim") or {}).get("unit")
            systemctl = os.environ.get("COUNCIL_SYSTEMCTL") or shutil.which("systemctl")
            if unit and systemctl:
                subprocess.run(
                    [systemctl, "--user", "stop", unit],
                    text=True,
                    capture_output=True,

Tainted flow: 'systemctl' from os.environ.get (line 746, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Confidence
88% confidence
Finding

This cancellation path also trusts COUNCIL_SYSTEMCTL from the environment and executes it directly. That permits environment-based executable hijacking during route cancellation, leading to arbitrary local code execution under the service account.

Content

Scanner excerpt · scripts/openwebui_tool.py (reported line 748)May include surrounding context.

python
unit = (status.get("claim") or {}).get("unit")
            systemctl = os.environ.get("COUNCIL_SYSTEMCTL") or shutil.which("systemctl")
            if unit and systemctl:
                subprocess.run(
                    [systemctl, "--user", "stop", unit],
                    text=True,
                    capture_output=True,

Intent-Code Divergence

Low
Category
Not specified by scanner
Confidence
71% confidence
Finding

The top-level docstring characterizes the script as creating and inspecting rooms safely, yet the code relies on direct mutation of the Open WebUI database and invocation of an external helper process. While not necessarily unsafe by itself, this contradicts the strong safety framing because the implementation uses higher-risk mechanisms than the documentation suggests.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Low
Category
Not specified by scanner
Confidence
77% confidence
Finding

Rather than operating only on explicit council-room resources, the code searches multiple filesystem locations under the workspace and home directory for a WebUI database. That host-level discovery behavior is not clearly implied by the manifest's concise description of council rooms and blackboards.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Low
Category
Not specified by scanner
Confidence
80% confidence
Finding

The council_doctor docstring says it checks configured helper paths and the Open WebUI database schema, which goes beyond the manifest's description of council rooms, typed blackboards, and handovers. Environment/database diagnostics for the hosting application are not an obvious direct requirement of the declared purpose.

Content

No source excerpt is available for this finding.