Back to skill

Security audit

backlog

Security checks for vulnerabilities and agentic risk

Overview

This backlog skill is a real task-tracker automation tool, but it also includes under-scoped Plane, Kubernetes, SSH, and direct database write paths that need review before installation.

Install only if you intentionally want this skill to mutate Plane backlog data and you are comfortable with its Kubernetes/SSH fallback paths. Use a dedicated low-privilege Plane token and, if cluster fallback remains enabled, a tightly scoped kubeconfig; prefer removing the Django-shell fallback and requiring HTTPS-only, no-redirect API calls before normal use.

Vulnerability Patterns
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • 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
Findings (3)

T04 · Embedded Malicious Code

Error
Location
scripts/plane_update_entity.py:226
Finding
Base64-Encoded Python Execution Inside Kubernetes Workloads and Remote SSH Targets<![CDATA[ ## Vulnerability Details **File Location**: `scripts/plane_update_entity.py:226-255` **Additional Locations**: `scripts/plane_create_entity.py:602-614`, `scripts/plane_create_entity.py:667-682`, `scripts/plane_create_issue.py:608-615` **Vulnerability Type**: Encoded code execution through Kubernetes and SSH **Risk Level**: Critical ### Vulnerable Code ```python b64_script = base64.b64encode(py_script.encode("utf-8")).decode("utf-8") k3s_ssh_host = profile.get("k3s_ssh_host") if k3s_ssh_host: cmd = [ "ssh", k3s_ssh_host, f"kubectl exec -n {k3s_namespace} {k3s_workload} -- python3 manage.py shell -c \"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))\"", ] else: cmd = [kubectl] if k3s_kubeconfig: cmd.extend(["--kubeconfig", k3s_kubeconfig]) cmd.extend( [ "exec", "-n", k3s_namespace, k3s_workload, "--", "python3", "manage.py", "shell", "-c", f"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))", ] ) try: proc = subprocess.run( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True ) ``` ### Technical Analysis The script constructs Python source code locally, Base64-encodes it, transfers it through a command-line argument, decodes it inside the Plane application workload, and executes it using `exec()`. The decoded payload observed during the audit is generated by the package itself and performs Plane Django ORM operations. It is not downloaded from an external server. Nevertheless, this design creates a general-purpose code-execution channel inside a privileged application container. It exceeds the minimum privileges needed for ordinary backlog synchronization, which can normally be performed through Plane's authenticated API. The same execution pattern is used by entity creation and ...[truncated 1899 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the Base64-plus-`exec()` execution path from normal Skill operation. 2. Implement creation, update, page, and intake operations through documented Plane APIs. 3. Fail closed when an API operation fails rather than automatically escalating to cluster-level access. 4. If administrative database repair remains necessary, move it into a separately installed operator utility that is not invoked automatically by the backlog Skill. 5. Require explicit operator confirmation before any Kubernetes or SSH operation. 6. Use a fixed, versioned, reviewed management command instead of dynamically generated Python. 7. Pass data through structured JSON or standard input and validate it against a strict schema. 8. Use a dedicated Kubernetes service account with narrowly scoped RBAC instead of relying on the caller's general `kubectl` context. 9. Restrict the allowed namespace, workload, SSH destination, and kubeconfig through an administrator-controlled allowlist. 10. Record the authenticated actor, requested operation, destination cluster, entity identifier, and result in an immutable audit log. 11. Add tests asserting that ordinary API failure never triggers remote code execution without a separate explicit administrative flag. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/plane_create_entity.py:315
Finding
Automatic Direct Database Writes Bypass Plane Authorization and Use Superuser Attribution<![CDATA[ ## Vulnerability Details **File Location**: `scripts/plane_create_entity.py:315-365` **Additional Locations**: `scripts/plane_create_entity.py:554-595`, `scripts/plane_update_entity.py:82-159` **Vulnerability Type**: Authorization bypass and misleading privileged attribution **Risk Level**: High ### Vulnerable Code ```python from plane.db.models import Issue, IntakeIssue, Workspace, Project, User ws = Workspace.objects.filter(slug={json.dumps(workspace_slug)}).first() prj = Project.objects.filter(id={json.dumps(prj_id)}).first() if prj is None: print(json.dumps({{"success": False, "reason": {json.dumps(f"project {prj_id} not found")}}})) raise SystemExit(0) u = User.objects.filter(is_superuser=True).first() or User.objects.first() # Idempotency check: look for existing issue with exact same title in project existing = Issue.objects.filter(project=prj, name={json.dumps(title)}).first() if existing: res = {{ "success": True, "method": "Existing (Idempotency Guard)", "id": str(existing.id), "sequence_id": existing.sequence_id, "title": existing.name, "url": f"{plane_host}/{workspace_slug}/projects/{{prj.id}}/issues/{{existing.id}}", "intake": {str(is_intake)} }} print("RESULT_JSON:" + json.dumps(res)) exit(0) ``` The generated script later creates records using the selected user: ```python issue = Issue.objects.create( name={json.dumps(title)}, description=tiptap_doc, description_html=html_desc, description_stripped=plain_desc, project=prj, workspace=ws, created_by=u{("," + chr(10) + " priority=" + json.dumps(normalized_priority)) if normalized_priority else ""} ) if {str(is_intake)}: try: IntakeIssue.objects.create( issue=issue, project=prj, workspace=ws, created_by=u, status=0 ) except Exception: pass ``` The update fallback also writes models ...[truncated 2983 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove direct ORM creation and update from the standard Skill execution path. 2. Require all normal operations to pass through authenticated Plane APIs. 3. Never select the first superuser or first user for `created_by`, `owned_by`, or similar attribution fields. 4. Preserve the authenticated caller's identity through an approved service-to-service authentication mechanism. 5. Fail closed when the authenticated actor cannot be determined. 6. Scope every entity lookup to the exact workspace and project. 7. Reject ambiguous sequence identifiers or title matches instead of falling back to global queries. 8. Use immutable UUIDs for updates wherever possible. 9. Do not silently suppress intake-record creation errors; return the error and roll back the operation where appropriate. 10. If direct database maintenance is operationally required, isolate it into a separate, administrator-only repair command with: - Explicit authorization checks. - Database transactions. - Dry-run support. - Exact tenant and project constraints. - Immutable audit logging. - A reviewed rollback procedure. 11. Add tests proving that one project's sequence identifier cannot resolve to another project's issue. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/plane_client.py:195
Finding
Plane API Credentials Can Be Sent over Plaintext or Forwarded Across Redirects<![CDATA[ ## Vulnerability Details **File Location**: `scripts/plane_client.py:195-202` **Additional Locations**: `scripts/plane_create_comment.py:59-66`, `scripts/plane_create_entity.py:252-280`, `scripts/plane_update_entity.py:297-340`, `scripts/plane_bulk_update.py:118-157` **Vulnerability Type**: Insecure credential transport and redirect handling **Risk Level**: High ### Vulnerable Code ```python def request(self, path, method="GET", data=None): """Issue one API call, retrying on 429 and throttling every response.""" url = "%s/api/v1/%s" % (self.profile["plane_host"], path.lstrip("/")) headers = { "x-api-key": self.profile["token"], "Content-Type": "application/json", "User-Agent": UA } body = json.dumps(data).encode("utf-8") if data is not None else None last_error = None for attempt in range(MAX_ATTEMPTS): req = urllib.request.Request( url, data=body, headers=headers, method=method ) try: with urllib.request.urlopen(req, timeout=30) as resp: payload = resp.read().decode("utf-8") ``` The comment client follows the same pattern: ```python def _request(method, url, token, payload=None, retries=5): data = json.dumps(payload).encode("utf-8") if payload is not None else None headers = { "x-api-key": token, "Content-Type": "application/json", "User-Agent": UA } last = None for attempt in range(retries): try: req = urllib.request.Request( url, data=data, headers=headers, method=method ) with urllib.request.urlopen(req, timeout=30) as resp: body = resp.read().decode("utf-8") return json.loads(body) if body else {} ``` The bulk-update client also places the API key in ordinary headers and invokes the default opener: ```python ...[truncated 2870 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Route all Plane traffic through one hardened transport implementation. 2. Parse `plane_host` with `urllib.parse.urlparse()` and reject: - Missing schemes. - Any scheme other than `https`. - Embedded user information. - Unexpected ports, if deployment policy permits a fixed port. - Hosts outside an administrator-controlled allowlist. 3. Install a redirect-refusing `HTTPRedirectHandler` for every authenticated request. 4. Never place credentials in headers that can be copied to a redirect request. 5. If redirects are operationally required, validate each destination and strip credentials unless the scheme, hostname, and port exactly match the approved origin. 6. Port the protections from `plane_sync.py` and `plane_create_issue.py` into `plane_client.py`, then require all other scripts to use that client. 7. Add explicit timeouts to every network operation, including intake and bulk-update calls. 8. Avoid logging complete exception bodies if they can contain sensitive server responses. 9. Add automated tests confirming: - HTTP hosts are rejected before any request is sent. - Cross-origin redirects are not followed. - HTTPS-to-HTTP redirects are rejected. - API keys are absent from redirected requests. - Profile-controlled unapproved hosts are rejected. 10. Rotate Plane API keys if affected scripts have previously contacted untrusted, plaintext, or unexpectedly redirecting endpoints. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (46)

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The description overstates the scope and generality of the skill compared with the supplied code. This script only handles one slice of functionality: intake creation for untracked fix_plan.md items into a specific Plane workspace. It uses hardcoded Plane endpoints, project identifiers, and an API key for Plane, so it is not vendor-agnostic. It also updates the local markdown backlog file with created issue links, which is a material write capability not mentioned in the declared permissions/purpose. While issue creation and triage/classification are partially aligned with the description, the primary behavior is much narrower than a unified backlog lifecycle manager and lacks the described sync, prune, comment, and state-transition features.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The description presents a broad, vendor-agnostic backlog management skill spanning multiple backlog types and operations. The supplied code instead implements a narrow synchronization utility for Plane only. It reads fix_plan.md, extracts issue keys, priorities, and dates, fetches live Plane issues, reports conflicts, and updates Plane priority/target_date fields. It does not manage session TODOs, handle checklist.md, classify requests, prune backlogs, create issues, post comments, or perform general lifecycle orchestration. While it does partially align with the declared 'priority' and 'sync' topics, its actual scope is materially narrower and vendor-specific, so the description does not accurately represent the code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The description presents a broad, vendor-agnostic backlog lifecycle manager covering triage, priority handling, external tracker sync, pruning, lifecycle state transitions, commenting, and issue creation across session/file/issue backlogs. The supplied code does only a small subset of that: it creates Plane issues and pages, with intake registration and priority mapping. It does not implement triage, backlog synchronization/polling, pruning, lifecycle transitions, DoD handling, or comment posting. It is also Plane-specific, not vendor-agnostic. Additionally, it includes a materially undeclared capability: creating wiki-style pages and directly invoking kubectl/SSH to run Django shell commands inside a K3s deployment. Those behaviors go beyond what a generic backlog-management description implies. Therefore the description does not accurately represent this code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The declared description presents a broad backlog management/orchestration skill with multiple lifecycle capabilities across different backlog types and vendor-agnostic issue trackers. The supplied code does something much narrower and materially different: it is a single-purpose Plane reconciliation/indexing script. It reads a local markdown tracker, fetches Plane issues, compares titles, checks whether local body text is already represented in Plane, and optionally replaces local blocks with indexed one-line references. While this loosely touches 'sync' with an issue tracker and local workspace checklist handling, it does not implement the majority of the declared capabilities such as triage, prioritization, pruning, lifecycle transitions, comments, or issue creation. Its resource scope is also specific to Plane rather than vendor-agnostic. Therefore the description overstates and misrepresents the actual behavior.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The description promises a broad vendor-agnostic backlog management capability spanning triage, synchronization, pruning, lifecycle management, comments, and issue creation across multiple backlog surfaces such as session TODOs and workspace checklist files. This code does not implement that overall behavior. Instead, it specifically updates existing Plane issues/pages, primarily their title, description, and priority. It also contains a significant undeclared capability: direct backend mutation through a K3s/Django shell fallback using kubectl or SSH, which is materially different from a generic backlog lifecycle abstraction. The code does not touch fix_plan.md/checklist.md, does not perform tracker sync polling, does not create issues, does not post comments, and does not manage session/file backlogs. While priority updating overlaps slightly with the declared topics, the actual primary purpose is much narrower and Plane-specific, so this is a clear description-behavior mismatch.

Agent Config Directory Access

High
Category
Agent Snooping
Content
for d in "${BACKLOG_SCRIPTS:-}" \
         "${CLAUDE_PLUGIN_ROOT:-}/skills/backlog/scripts" \
         "${AGENT_SKILLS_HOME:-$HOME/.agents}/skills/backlog/scripts" \
         "${GEMINI_SKILLS_HOME:-$HOME/.gemini/config}/skills/backlog/scripts"; do
  [ -n "$d" ] && [ -d "$d" ] && BACKLOG_SCRIPTS="$d" && break
done
```
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
for d in "${BACKLOG_SCRIPTS:-}" \
         "${CLAUDE_PLUGIN_ROOT:-}/skills/backlog/scripts" \
         "${AGENT_SKILLS_HOME:-$HOME/.agents}/skills/backlog/scripts" \
         "${GEMINI_SKILLS_HOME:-$HOME/.gemini/config}/skills/backlog/scripts"; do
  [ -n "$d" ] && [ -d "$d" ] && BACKLOG_SCRIPTS="$d" && break
done
```
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
The documented automatic fallback from the intended Plane REST API to `kubectl exec` plus Django shell materially expands the skill's authority from scoped application API use to infrastructure-level code execution inside the Plane deployment. That bypasses normal application-layer authorization boundaries, auditing expectations, and change controls, so a routine backlog-creation action could become a privileged cluster-side write path without explicit user consent.

Lp1

High
Category
MCP Least Privilege
Confidence
97% confidence
Finding
The script performs outbound network requests to Plane APIs, including POST requests that create issues and GET requests that enumerate projects, but network capability is not declared in the skill permissions. This is risky because the skill can exfiltrate backlog contents and mutate external systems by creating records without transparent permissioning, which is especially sensitive for a backlog-management skill handling internal task data.

Lp1

High
Category
MCP Least Privilege
Confidence
97% confidence
Finding
The script performs outbound network requests to Plane APIs, including POST requests that create issues and GET requests that enumerate projects, but network capability is not declared in the skill permissions. This is risky because the skill can exfiltrate backlog contents and mutate external systems by creating records without transparent permissioning, which is especially sensitive for a backlog-management skill handling internal task data.

Lp1

High
Category
MCP Least Privilege
Confidence
90% confidence
Finding
The file has undeclared shell-capable behavior through kubectl/ssh/Django-shell execution, which means the skill's effective privileges exceed what consumers may expect from its declared contract. In an agent setting, hidden execution capabilities are dangerous because they bypass user intent boundaries and can be combined with untrusted inputs or environment configuration.

Credential Access

High
Category
Privilege Escalation
Content
- --type page: Page (wiki-style doc) creation, K3s Django-shell only (no REST
    attempt — that endpoint's behavior on this workspace hasn't been verified)

K3s fallback target (namespace/kubeconfig) comes from the resolved workspace
profile (workspace_profile.py's k3s_namespace/k3s_kubeconfig, propagated by
plane_client.resolve_profile) — set these per-workspace rather than assuming
a single kubectl context. Getting this wrong silently creates the
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- --type page: Page (wiki-style doc) creation, K3s Django-shell only (no REST
    attempt — that endpoint's behavior on this workspace hasn't been verified)

K3s fallback target (namespace/kubeconfig) comes from the resolved workspace
profile (workspace_profile.py's k3s_namespace/k3s_kubeconfig, propagated by
plane_client.resolve_profile) — set these per-workspace rather than assuming
a single kubectl context. Getting this wrong silently creates the
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- --type page: Page (wiki-style doc) creation, K3s Django-shell only (no REST
    attempt — that endpoint's behavior on this workspace hasn't been verified)

K3s fallback target (namespace/kubeconfig) comes from the resolved workspace
profile (workspace_profile.py's k3s_namespace/k3s_kubeconfig, propagated by
plane_client.resolve_profile) — set these per-workspace rather than assuming
a single kubectl context. Getting this wrong silently creates the
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- --type page: Page (wiki-style doc) creation, K3s Django-shell only (no REST
    attempt — that endpoint's behavior on this workspace hasn't been verified)

K3s fallback target (namespace/kubeconfig) comes from the resolved workspace
profile (workspace_profile.py's k3s_namespace/k3s_kubeconfig, propagated by
plane_client.resolve_profile) — set these per-workspace rather than assuming
a single kubectl context. Getting this wrong silently creates the
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- --type page: Page (wiki-style doc) creation, K3s Django-shell only (no REST
    attempt — that endpoint's behavior on this workspace hasn't been verified)

K3s fallback target (namespace/kubeconfig) comes from the resolved workspace
profile (workspace_profile.py's k3s_namespace/k3s_kubeconfig, propagated by
plane_client.resolve_profile) — set these per-workspace rather than assuming
a single kubectl context. Getting this wrong silently creates the
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
b64_script = base64.b64encode(py_script.encode('utf-8')).decode('utf-8')
    namespace = profile.get("k3s_namespace") or "plane"
    kubeconfig = profile.get("k3s_kubeconfig")
    cmd = ["kubectl"]
    if kubeconfig:
        cmd += ["--kubeconfig", kubeconfig]
Confidence
84% confidence
Finding
The code retrieves a kubeconfig path from the resolved profile and uses it to authenticate kubectl access to a Kubernetes cluster. While it does not directly exfiltrate credentials, it operationalizes privileged cluster credentials from the skill context, enabling backend access well beyond normal issue creation and increasing the consequences of compromise or misuse.

Credential Access

High
Category
Privilege Escalation
Content
namespace = profile.get("k3s_namespace") or "plane"
    kubeconfig = profile.get("k3s_kubeconfig")
    cmd = ["kubectl"]
    if kubeconfig:
        cmd += ["--kubeconfig", kubeconfig]
    cmd += [
        "exec", "-n", namespace, "deploy/plane-api-wl", "--",
Confidence
84% confidence
Finding
This branch applies the kubeconfig to a kubectl command, activating cluster credentials for subsequent pod execution. In the context of an agent skill, using infrastructure credentials directly is dangerous because a task-management tool now has a path to authenticated cluster operations unrelated to its primary purpose.

Credential Access

High
Category
Privilege Escalation
Content
kubeconfig = profile.get("k3s_kubeconfig")
    cmd = ["kubectl"]
    if kubeconfig:
        cmd += ["--kubeconfig", kubeconfig]
    cmd += [
        "exec", "-n", namespace, "deploy/plane-api-wl", "--",
        "python3", "manage.py", "shell", "-c",
Confidence
83% confidence
Finding
Here the kubeconfig-backed kubectl invocation is coupled with exec into the Plane API pod, turning credential use into active privileged workload access. The issue is not mere possession of credentials, but that the skill immediately uses them to cross trust boundaries into cluster and application internals.

Obfuscated Code

High
Category
Supply Chain
Content
cmd += [
        "exec", "-n", namespace, "deploy/plane-api-wl", "--",
        "python3", "manage.py", "shell", "-c",
        f"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))"
    ]
    try:
        res = subprocess.run(cmd, capture_output=True, text=True, check=True)
Confidence
97% confidence
Finding
This line decodes base64 and execs the resulting Python inside the Plane API container, which is an obfuscated arbitrary-code execution pattern. Even if the encoding is used for quoting convenience, the effect is to hide dynamically generated code and bypass normal validation boundaries, making review, monitoring, and abuse detection much harder.

Context-Inappropriate Capability

High
Confidence
99% confidence
Finding
The skill intentionally builds Python source, base64-encodes it, and executes it inside a Kubernetes-hosted Plane API pod through manage.py shell, optionally over ssh. This is effectively arbitrary code execution in the backend application environment, likely with access to application secrets, database models, and privileged service accounts, far beyond what is needed to create issues or pages.

Obfuscated Code

High
Category
Supply Chain
Content
cmd = [
            "ssh",
            k3s_ssh_host,
            f"kubectl exec -n {k3s_namespace} {k3s_workload} -- python3 manage.py shell -c \"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))\"",
        ]
    else:
        cmd = [
Confidence
98% confidence
Finding
This ssh command transmits a kubectl exec that runs base64-decoded Python in the remote cluster, combining remote shell access, cluster access, and dynamic code execution. That stack of capabilities creates a severe trust-boundary violation and makes the backlog skill materially more dangerous than its stated business purpose suggests.

Obfuscated Code

High
Category
Supply Chain
Content
cmd = [
            "kubectl", "exec", "-n", k3s_namespace, k3s_workload, "--",
            "python3", "manage.py", "shell", "-c",
            f"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))"
        ]
    try:
        res = subprocess.run(cmd, capture_output=True, text=True, check=True)
Confidence
97% confidence
Finding
This local kubectl path again performs base64-decoded exec of generated Python in the application pod. The encoding does not mitigate risk; it conceals a highly privileged code-execution channel that can alter data, access secrets, or pivot further within the cluster.

Obfuscated Code

High
Category
Supply Chain
Content
cmd = [
        "kubectl", "exec", "-n", k3s_namespace, k3s_workload, "--",
        "python3", "manage.py", "shell", "-c",
        f"import base64; exec(base64.b64decode('{b64_script}').decode('utf-8'))"
    ]
    try:
        res = subprocess.run(cmd, capture_output=True, text=True, check=True)
Confidence
97% confidence
Finding
The base64-decoded `exec(...)` is obfuscation around dynamically generated Python that is executed inside the Kubernetes-hosted Django shell. Even if used here to transport multiline code safely, it conceals a powerful remote code-execution path and makes review, monitoring, and policy enforcement harder, increasing the risk of misuse or later abuse.

Credential Access

High
Category
Privilege Escalation
Content
or os.environ.get("PLANE_K3S_WORKLOAD")
        or "deploy/plane-api-wl"
    )
    k3s_kubeconfig = profile.get("k3s_kubeconfig") or os.environ.get("PLANE_K3S_KUBECONFIG")

    py_script = build_k3s_update_script(
        workspace_slug,
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

Detected: suspicious.dynamic_code_execution

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/test_plane_priority_mapping.py:28

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/test_plane_sync.py:21