Back to skill

Security audit

Jira Access

Security checks for vulnerabilities and agentic risk

Overview

This Jira skill mostly matches its stated purpose, but it needs review because it can change live Jira data and sends the Jira API token to the configured domain without validating it.

Install only if you trust the publisher and can tightly control the runtime environment. Set JIRA_DOMAIN only to the intended Atlassian tenant, use a least-privileged Jira API token, rotate any token that may have run with an untrusted domain, and require explicit user approval before create, transition, or comment commands.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/jira_cli.py:18
Finding
Jira credentials can be transmitted to an attacker-controlled host<![CDATA[ ## Vulnerability Details **File Location**: `scripts/jira_cli.py:18-27` **Vulnerability Type**: Unvalidated credential destination **Risk Level**: High ### Vulnerable Code ```python BASE_URL = f"https://{os.getenv('JIRA_DOMAIN')}/rest/api/3" AUTH = (os.getenv('JIRA_EMAIL'), os.getenv('JIRA_API_TOKEN')) if not all([os.getenv('JIRA_DOMAIN'), os.getenv('JIRA_EMAIL'), os.getenv('JIRA_API_TOKEN')]): sys.stderr.write('Missing required JIRA environment variables.\n') sys.exit(1) def jira_request(method, path, **kwargs): url = f"{BASE_URL}{path}" resp = requests.request(method, url, auth=AUTH, headers={'Accept': 'application/json'}, **kwargs) resp.raise_for_status() return resp.json() ``` ### Technical Analysis The destination hostname is constructed directly from the `JIRA_DOMAIN` environment variable without validating that it is the intended Jira Cloud workspace or even an Atlassian-controlled hostname. The same request is supplied with HTTP Basic Authentication containing `JIRA_EMAIL` and `JIRA_API_TOKEN`. HTTPS only protects transport to the selected server; it does not establish that the selected server is trustworthy. If `JIRA_DOMAIN` is changed to a hostname controlled by an attacker, the first Jira operation sends the victim's Basic Authentication header to that server. This contradicts the Skill metadata, which identifies a specific Jira workspace, but the implementation does not pin or allowlist that workspace. ### Attack Path 1. An attacker influences the Skill's runtime configuration, deployment environment, shell profile, `.env` source, or CI variables. 2. The attacker sets `JIRA_DOMAIN` to a server under their control while valid values remain configured for `JIRA_EMAIL` and `JIRA_API_TOKEN`. 3. A user or agent invokes any command, such as `jira list`. 4. The script constructs a URL under the attacker's hostname. 5. `requests` creates a Basic Authentication header from the Jira email and API token and sends it ...[truncated 832 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the expected hostname when the Skill is designed for one specific workspace: ```python from urllib.parse import urlparse EXPECTED_HOST = "omeshkshatriya.atlassian.net" configured_host = os.environ.get("JIRA_DOMAIN", "").strip().lower() if configured_host != EXPECTED_HOST: raise ValueError("JIRA_DOMAIN is not an approved Jira hostname") BASE_URL = f"https://{EXPECTED_HOST}/rest/api/3" ``` 2. If multiple tenants must be supported, parse and validate the value as a hostname and enforce a strict allowlist. Do not accept URL schemes, credentials, ports, paths, query strings, fragments, IP addresses, or arbitrary domains. 3. Restrict approved hosts to explicitly configured Jira tenants rather than relying only on a broad suffix check. 4. Disable redirects for authenticated requests unless they are explicitly required: ```python resp = requests.request( method, url, auth=AUTH, headers={"Accept": "application/json"}, allow_redirects=False, timeout=30, **kwargs, ) ``` 5. If redirects are required, validate every redirect destination before resending a request and never forward credentials to a different origin. 6. Add connection and read timeouts and fail closed on validation errors. 7. Protect deployment environment variables and CI configuration from modification by untrusted users. 8. Revoke and rotate the Jira API token if the Skill has previously run with an untrusted `JIRA_DOMAIN`. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:33
Finding
Unpinned third-party dependency installation creates supply-chain exposure<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:33-36` **Vulnerability Type**: Unpinned runtime dependency **Risk Level**: Medium ### Vulnerable Code ```powershell 2. Ensure Python 3.9+ is installed on Windows and install the required dependency: ```powershell pip install requests ``` ``` ### Technical Analysis The setup instructions install `requests` without an exact version, lock file, integrity hash, or explicitly trusted package index. Consequently, the package version and its transitive dependencies can change between installations without any corresponding change to the audited project. This weakens reproducibility and allows future compromised, malicious, or incompatible dependency releases to enter the runtime automatically. Package-index substitution or a compromised package source can further cause an unintended artifact to be installed. Because Python packages and installation tooling can execute code in the local environment, dependency compromise can affect both setup and subsequent Skill execution. ### Attack Path 1. A user follows the documented setup procedure. 2. `pip` resolves the latest available `requests` package and its transitive dependencies from the configured package index. 3. A package, dependency, index, mirror, or account in the supply chain is compromised, or the runtime is configured to use an untrusted index. 4. `pip` downloads and installs the unreviewed artifact. 5. Malicious package code executes during installation or when `jira_cli.py` imports `requests`. 6. The malicious code runs with the privileges of the user running the installation or Jira Skill. ### Impact Assessment A compromised dependency executes within the Skill's process and can access resources available to that process, including: - `JIRA_EMAIL`, `JIRA_API_TOKEN`, and other environment variables. - Jira issue data returned by API calls. - Files readable or writable by the executing user. - Network resources reachable from ...[truncated 309 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Declare dependencies in a reviewed requirements or lock file using exact versions. 2. Generate and verify cryptographic hashes for all direct and transitive packages. For example: ```text requests==<reviewed-version> --hash=sha256:<verified-hash> ``` 3. Install with hash enforcement: ```powershell python -m pip install --require-hashes -r requirements.txt ``` 4. Pin all transitive dependencies or use a lock-file tool that records the complete resolved dependency graph. 5. Install only from an explicitly trusted package index and prevent fallback to untrusted extra indexes. 6. Review dependency updates before modifying the lock file and use automated vulnerability and provenance scanning. 7. Perform installation in an isolated virtual environment with minimal privileges. 8. Avoid exposing Jira credentials during dependency installation; supply them only when the reviewed application is executed. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (8)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill requires access to environment variables and the network, but it does not declare any explicit tool scope or allowed-tools boundary. In a credentialed Jira integration, this weakens least-privilege controls and can allow broader-than-expected execution or secret access if the runtime grants defaults.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The trigger text says to activate on any request that mentions Jira operations, which is overly broad for a skill that can both read and modify issue data. Over-triggering can cause the assistant to invoke this skill in ambiguous contexts and perform unintended actions against a live Jira tenant using stored credentials.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill description emphasizes operational capabilities but does not clearly warn that it can modify Jira data. In practice, this can lead users or orchestrators to treat the skill as informational when it is capable of creating issues, transitioning workflow state, and adding comments or attachments.

Description-Behavior Mismatch

Medium
Confidence
96% confidence
Finding
The code implements a comment operation that is not disclosed in the skill metadata, creating a capability mismatch between what reviewers/users expect and what the tool can actually do. Hidden write capabilities are dangerous in agentic settings because they expand the action surface beyond the declared scope and could be invoked without appropriate policy, review, or user awareness.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The create, transition, and comment commands directly perform state-changing requests against a live Jira instance with no built-in confirmation, dry-run mode, or user-approval checkpoint. In an agent context, this raises the risk of accidental or prompt-induced remote modifications, especially since the skill is designed to trigger broadly on Jira-related requests.

Description-Behavior Mismatch

Low
Confidence
95% confidence
Finding
The manifest description limits the skill to listing, creating, and transitioning Jira issues, but the SKILL.md overview and usage also describe adding comments and attachments. That expands the described behavior beyond the manifest’s stated scope, even though it remains within Jira.

Natural-Language Policy Violations

Low
Confidence
62% confidence
Finding
The documentation states 'Ensure Python 3.9+ is installed on Windows' and labels PowerShell as recommended, which imposes a specific platform context without indicating whether alternatives are supported. This is a mild natural-language policy concern because it constrains usage without explicit opt-in or justification.

Description-Behavior Mismatch

Low
Confidence
87% confidence
Finding
The parser exposes a comment subcommand while the surrounding skill description says to use the skill for Jira operations but does not mention commenting. This inconsistency can cause downstream tooling or reviewers to under-classify the skill's write capabilities, making unauthorized or unexpected comments more likely in practice.

Static analysis

No suspicious patterns detected.