Jenkins

Server-Side Request Forgery in PraisonAI's Jobs API (pip/praisonai < 4.6.58) results from two compounding flaws: a fail-open DNS error handler in `JobSubmitRequest.validate_webhook_url()` that silently accepts any webhook URL when `socket.gaierror` is raised, and a TOCTOU race where `JobExecutor._send_webhook()` performs a completely independent DNS resolution via `httpx.AsyncClient` minutes to hours after validation. Authenticated attackers with a valid API bearer token can submit a job whose `webhook_url` hostname returns NXDOMAIN at validation time, then update DNS to a private IP before job completion, causing the executor to POST job result data to internal infrastructure. A detailed proof-of-concept is publicly available in GHSA-rg5q-pp8p-f7jm; no public exploit identified at time of analysis beyond the PoC, and this CVE is not listed in CISA KEV.

Arbitrary file read on the Jenkins controller affects Jenkins through LTS 2.555.3, where an authenticated attacker holding Item/Configure permission can exfiltrate any file readable by the Jenkins process user by uploading a crafted tar archive containing a symlink. This is an incomplete-fix bypass of CVE-2026-33001: the prior patch validated where a symlink is placed during extraction but not where it points, so a link staged inside the workspace can still resolve to paths outside it. There is no public exploit identified at time of analysis, and the flaw is not listed in CISA KEV, but it directly exposes secrets/master.key, credentials.xml, and other sensitive configuration.

Case-insensitivity handling inconsistency in Jenkins 2.575 and earlier allows attackers to impersonate existing users or inherit their permissions by registering accounts with Unicode characters that case-insensitively match existing usernames. Jenkins generates canonical user IDs via lowercasing but performs comparisons using Java's `String#equalsIgnoreCase`, which follows Unicode case-folding semantics - for example, the Turkish dotless 'ı' is treated as equal to 'i' during comparison but produces a different canonical ID when lowercased. Exploitation is constrained to deployments using external security realms that permit non-ASCII characters in usernames; no public exploit has been identified at time of analysis.

Remote code execution and privilege escalation are the headline risks in this Jenkins advisory covering multiple vulnerabilities in Jenkins core (versions 2.575/LTS 2.568.1 and earlier) and eleven plugins. The most critical flaw (CVE-2026-70426) bypasses the JEP-200 deserialization class filter via a fallback path in the Remoting library, allowing an agent process or a user with Agent/Connect permission to execute arbitrary code on the Jenkins controller. A companion archive-extraction vulnerability (CVE-2026-70427) enables arbitrary file writes to the controller filesystem - including into init.groovy.d or the plugins directory - through crafted tar/tar.gz archives delivered from an agent; no public exploits or CISA KEV listing were identified for any issue in this advisory at time of analysis.

Cross-site request forgery (CSRF) in a Jenkins plugin (SECURITY-3888) allows unauthenticated remote attackers to induce authenticated Jenkins users into triggering unauthorized plugin actions by visiting a malicious page, with no privileges required on the attacker's side. The companion vulnerability CVE-2026-70435 covers a missing permission check in the same plugin, indicating the CSRF-triggered endpoint also lacks server-side authorization enforcement. Fixes are available in the 2026-08-05 Jenkins security advisory bundle; no public exploit or CISA KEV listing has been identified at time of analysis.

CVE-2026-70443 is part of the Jenkins August 5, 2026 batch security advisory covering Jenkins core and multiple plugins. The provided source data does not include the specific vulnerability description for CVE-2026-70443 - the advisory text is truncated before reaching this CVE identifier (described CVEs end around CVE-2026-70435). The full advisory at https://www.jenkins.io/security/advisory/2026-08-05/ contains authoritative details. No active exploitation is confirmed (not listed in CISA KEV), and no EPSS or CVSS data was provided in the source intelligence.

Missing permission checks in HCL AppScan Plugin 1.8.3 and earlier expose multiple Jenkins HTTP endpoints to any authenticated user holding Overall/Read permission, enabling enumeration of credentials IDs stored in Jenkins. Credential ID disclosure is a stepping-stone attack: while the raw secrets are not returned, knowledge of credential IDs can be combined with a separate vulnerability to capture those credentials. No public exploit or active exploitation has been confirmed. A patched release (1.8.4) is available.

Remote code execution and privilege escalation across Jenkins core and multiple plugins were disclosed in the 2026-08-05 security advisory, with the most critical issue being a JEP-200 deserialization filter bypass (CVE-2026-70426) in Remoting 3384.v60d89463d9e0 and earlier that allows agent processes or holders of Agent/Connect permission to execute arbitrary code on the Jenkins controller. Compounding this, two separate arbitrary file-write primitives (CVE-2026-70427 via malicious tar archives, CVE-2026-70428 via path traversal in file parameter names) independently enable code execution by writing into JENKINS_HOME/init.groovy.d/ or deploying rogue plugins. No public exploit code or CISA KEV listing was identified at time of analysis, but the attack surface spans both network-accessible agents and authenticated users with low-privilege build permissions.

Remote code execution, arbitrary file write, and privilege escalation vulnerabilities in Jenkins 2.575 and earlier (LTS 2.568.1 and earlier) expose the Jenkins controller to full compromise via agent-initiated attacks. The most critical paths - a JEP-200 deserialization filter bypass (CVE-2026-70426) and a symlink-based arbitrary file write through tar archive handling (CVE-2026-70427) - both allow attacker-controlled agent processes to execute code on the Jenkins controller JVM. Additional vulnerabilities in Multijob, HCL AppScan, and SCM-Manager plugins introduce unauthenticated Groovy RCE, CSRF-triggered code execution, and credential enumeration. No EPSS data or CISA KEV listing is present in available intelligence; no public exploit code is noted at time of analysis.

Remote code execution, arbitrary file write, and privilege escalation vulnerabilities in Jenkins core (through 2.575 / LTS 2.568.1) and multiple plugins expose CI/CD infrastructure to full controller compromise. The most critical issue (CVE-2026-70426) allows agent processes and users with Agent/Connect permission to bypass the JEP-200 deserialization class filter via an unguarded fallback path in the Remoting library, enabling code execution on the Jenkins controller. Two independent arbitrary file write vectors (CVE-2026-70427 via malicious tar archives, CVE-2026-70428 via path traversal in file parameter names) can achieve equivalent controller-level code execution by writing Groovy scripts to JENKINS_HOME/init.groovy.d/ or deploying rogue plugins. No CISA KEV listing or public exploit has been identified at time of analysis, though the Jenkins security team coordinated a pre-announcement, suggesting no known active exploitation at disclosure.

Jenkins 2.575 and LTS 2.568.1 and earlier, along with a broad set of Jenkins plugins, are affected by a batch of security vulnerabilities disclosed in the 2026-08-05 advisory. CVE-2026-70438 is one of the CVEs issued under this advisory batch; based on sequential numbering (the described CVEs run from 70426 through approximately 70435+), it likely corresponds to one of the eleven plugins listed as carrying unresolved security issues without a fix at time of publication - including AWS CodeBuild, CodeSonar, Google Chat Notification, Horreum, Ivy Report, Parameterized Remote Trigger, Qualys Container Scanning Connector, Sauce OnDemand, Summary Display, Violation Comments to GitLab, and XML Job to Job DSL. No public exploit has been identified for CVE-2026-70438 specifically, and it does not appear in CISA KEV. The broader advisory includes critical issues such as a Remoting deserialization filter bypass enabling controller-side code execution from agent processes, path traversal enabling arbitrary file write, and CSRF or missing permission checks across multiple plugins.

CVE-2026-70441 is assigned within the Jenkins security advisory published 2026-08-05, which discloses over a dozen vulnerabilities across Jenkins core (2.575 and earlier, LTS 2.568.1 and earlier) and multiple plugins. The provided description is the full oss-security announcement for this advisory batch; the specific vulnerability details mapped to CVE-2026-70441 are not isolated in the available data due to truncation of the source text. The advisory as a whole addresses remote code execution via deserialization filter bypass, arbitrary file write via path traversal and crafted archive extraction, CSRF, permission bypass, and user impersonation flaws. No public exploit, KEV listing, or EPSS score was provided for CVE-2026-70441 individually.

Unrestricted object instantiation in Jenkins 2.575 and earlier (LTS 2.568.1 and earlier) allows users holding Overall/Manage permission to instantiate arbitrary Java types through the project naming strategy configuration, including configuration objects intended exclusively for full administrators. This effectively breaks the permission boundary between Overall/Manage holders and full system administrators, enabling privilege escalation within the Jenkins controller. No public exploit has been identified at time of analysis, but fixed releases (Jenkins 2.576 and LTS 2.568.2) are available and should be applied promptly.

CVE-2026-70445 is one of multiple security vulnerabilities disclosed in the Jenkins security advisory published 2026-08-05, affecting Jenkins core and a range of Jenkins plugins. The specific vulnerability details for this CVE ID were not included in the provided input data - the oss-security disclosure text was truncated before reaching the description of CVE-2026-70445, which falls beyond CVE-2026-70435 in the sequential numbering. Based on the advisory structure, this CVE likely pertains to one of the Jenkins plugins listed either as patched (External Workspace Manager, HCL AppScan, Multijob, SCM-Manager, Webhook Secret Credentials Provider) or as containing unresolved issues (AWS CodeBuild, CodeSonar, Google Chat Notification, Horreum, Ivy Report, Parameterized Remote Trigger, Qualys Container Scanning Connector, Sauce OnDemand, Summary Display, Violation Comments to GitLab, XML Job to Job DSL). No public exploit, KEV listing, or EPSS score was provided.

Multiple high-severity vulnerabilities in Jenkins core and a range of plugins disclosed in the August 2026 security advisory allow attackers to achieve remote code execution on the Jenkins controller, perform arbitrary file writes, bypass deserialization protections, impersonate users, and enumerate stored credentials. Affected versions include Jenkins 2.575 and LTS 2.568.1 and earlier, with the most critical issues residing in the Remoting deserialization layer (CVE-2026-70426), tar archive handling (CVE-2026-70427), and file parameter path traversal (CVE-2026-70428), all of which ultimately enable code execution on the controller JVM. No public exploit or CISA KEV listing is confirmed at time of analysis, but the attack surface breadth and severity of RCE-capable issues make this advisory a high-priority patching event for any Jenkins deployment.

Remote code execution on the Jenkins controller is achievable by attackers holding Agent/Connect permission via a JEP-200 deserialization filter bypass in the Remoting library (agent.jar/remoting.jar). Jenkins 2.575 and earlier, and LTS 2.568.1 and earlier, include a Remoting version (3384.v60d89463d9e0 and earlier, except the backport 3355.3357.v931d3c992987) that fails to apply the JEP-200 class filter to a fallback deserialization code path, allowing crafted serialized Java objects to reach classes on the Jenkins core classpath that are not blocked by the pre-JEP-200 denylist. No public exploit or CISA KEV listing has been identified at time of analysis, but the primitive - controller-side code execution triggered from an agent - represents a critical trust-boundary violation in Jenkins' controller-agent architecture.

CVE-2026-70437 is part of the Jenkins project's August 5, 2026 security advisory (jenkins.io/security/advisory/2026-08-05/), which addressed vulnerabilities across Jenkins core and at least ten plugins. The specific description for CVE-2026-70437 was not included in the provided data excerpt - the source text enumerates CVE-2026-70426 through CVE-2026-70435 before truncating. Based on sequential CVE assignment within this advisory, CVE-2026-70437 likely maps to one of the plugin fixes not yet accounted for: External Workspace Manager Plugin 1.4.2, SCM-Manager Plugin 1.12.1, or Webhook Secret Credentials Provider Plugin 32.v09c9b_522f0a_8, or to an unresolved issue in one of the eleven plugins named without fixes.

Remote code execution via CSRF in Jenkins Multijob Plugin 669.v9d96a_d9c71b_0 and earlier allows a network attacker to execute arbitrary code within the Jenkins controller JVM by inducing a low-privileged authenticated user to trigger a forged request. The Jenkins security advisory published 2026-08-05 formally discloses this as SECURITY-3823(2), with EUVD-2026-53526 corroborating the affected version range. No public exploit code or CISA KEV listing has been identified at time of analysis, though the network reachability and low attack complexity make this a meaningful risk wherever Jenkins is accessible and users browse untrusted sites within the same browser session.

Arbitrary file write via crafted tar archive extraction in Jenkins 2.575 and earlier allows attackers controlling agent processes to escape extraction directory boundaries on the controller filesystem, directly enabling remote code execution. The root cause is unsafe handling of symbolic links with effectively empty names during .tar and .tar.gz extraction on the controller, permitting writes to sensitive paths such as JENKINS_HOME/init.groovy.d/ (Groovy init scripts) or JENKINS_HOME/plugins/ (plugin deployment). No public exploit or CISA KEV listing has been identified at time of analysis, but the agent-to-controller trust boundary is a well-established Jenkins attack surface with a history of critical exploitation.

The August 2026 Jenkins security advisory discloses multiple severe vulnerabilities across Jenkins core (2.575/LTS 2.568.1 and earlier) and several plugins, with the most critical being a JEP-200 deserialization class filter bypass (CVE-2026-70426) enabling remote code execution on the Jenkins controller from agent processes, and a symlink-based path traversal in tar archive extraction (CVE-2026-70427) permitting arbitrary file writes that achieve controller RCE via init scripts or plugin deployment. Additional high-severity issues include a second path traversal via file parameter names (CVE-2026-70428), Unicode-based user identity impersonation (CVE-2026-70429), arbitrary type instantiation by privileged users (CVE-2026-70430), and unsandboxed Groovy RCE in the Multijob Plugin (CVE-2026-70431/70432). No active exploitation is confirmed at time of analysis, but the exploitability of agent-to-controller RCE paths in Jenkins is a well-understood and historically targeted vulnerability class warranting immediate remediation.

Jenkins 2.575 and earlier (LTS 2.568.1 and earlier) and multiple Jenkins plugins contain a cluster of vulnerabilities ranging from remote code execution via deserialization filter bypass to path traversal, CSRF, permission check failures, and Unicode-based user impersonation. The most critical issue - a bypass of the JEP-200 class filter in the Remoting library - allows authenticated agent operators or principals holding Agent/Connect permission to execute arbitrary code on the Jenkins controller. Three separate avenues for controller-side code execution are present in this advisory: the Remoting deserialization bypass (CVE-2026-70426), a tar archive symlink path traversal (CVE-2026-70427), and a file parameter path traversal (CVE-2026-70428). No public exploit or CISA KEV listing is confirmed at time of analysis, but the severity and variety of attack paths make this advisory high-priority for any Jenkins deployment.

Missing permission check in a Jenkins plugin (SECURITY-3888) exposes one or more HTTP endpoints to attackers without adequate authorization enforcement. The vulnerability is one of a paired finding alongside CVE-2026-70434 (CSRF), suggesting the same endpoint lacks both CSRF protection and proper access controls. The full description is truncated in the available source data, so the specific plugin and endpoint are not independently confirmed, but fixes are included in the August 5, 2026 Jenkins security advisory. No public exploit is identified at time of analysis.

Unsandboxed Groovy script execution in Jenkins Multijob Plugin 669.v9d96a_d9c71b_0 and earlier allows any attacker holding Item/Create or Item/Configure permission to run arbitrary code directly on the Jenkins controller JVM. The plugin exposes Groovy scripting capabilities that intentionally bypass the Script Security Plugin - the standard Jenkins mechanism for confining script execution to a restricted sandbox - meaning scripts execute with the full privileges of the Jenkins service account. The fix is available in Multijob Plugin 677.v7ffc23d6a_4c2; no public exploit has been identified at time of analysis and this CVE is not listed in the CISA KEV catalog.

CVE-2026-70439 is part of the Jenkins multi-CVE security advisory published August 5, 2026, covering vulnerabilities across Jenkins core and multiple plugins. The advisory batch includes critical issues such as a Remoting deserialization filter bypass enabling controller code execution (CVE-2026-70426), arbitrary file write via crafted tar archives (CVE-2026-70427), and path traversal enabling script deployment (CVE-2026-70428). The specific technical details for CVE-2026-70439 are not present in the available data - the oss-security disclosure is truncated and covers only CVE-2026-70426 through the beginning of CVE-2026-70435 before cutting off. No public exploit or CISA KEV listing is confirmed for CVE-2026-70439 at time of analysis.

Path traversal in Jenkins file parameter name validation allows authenticated attackers holding Item/Configure and Item/Build permissions to write arbitrary files to the Jenkins controller's file system, leading to code execution. Affected releases are Jenkins 2.575 and earlier (weekly) and LTS 2.568.1 and earlier; fixed in Jenkins 2.576 and LTS 2.568.2, published 2026-08-05. No public exploit code or CISA KEV listing has been identified at time of analysis.

Server-side request forgery and OIDC token forgery in Eclipse CSI PIA lets an unauthenticated attacker abuse a flawed Jenkins issuer allowlist (a bare `startswith('https://ci.eclipse.org')` check in `is_issuer_known`, pia/models.py:139) to redirect OIDC discovery and JWKS fetches to an attacker-controlled host. By posting a crafted issuer such as `https://ci.eclipse.org@evil.host` or `https://ci.eclipse.org.evil.host` to `POST /v1/upload/sbom`, an attacker forces PIA to make outbound requests to arbitrary hosts and to accept a JWT signed with the attacker's own key, effectively bypassing token verification. No public exploit identified at time of analysis, but the flaw is unauthenticated and network-reachable, and the CVSS 3.1 base score is 8.2.

Missing authorization in Jenkins Zowe zDevOps Plugin (≤1.1.3.50.ve350c9b_450b_1) allows an authenticated low-privilege user holding only Overall/Read permission to invoke an unprotected plugin endpoint, supplying attacker-controlled connection parameters and externally obtained credential IDs to capture secrets stored in the Jenkins credential store. The Jenkins project confirmed the flaw under SECURITY-3747 and published an advisory on 2026-06-24. No public exploit code or active exploitation has been identified; EPSS places this at the 3rd percentile and SSVC rates exploitation as none with non-automatable attack mechanics.

Cross-site request forgery in Jenkins Zowe zDevOps Plugin version 1.1.3.50.ve350c9b_450b_1 and earlier enables network-based attackers to force authenticated Jenkins users into making unauthorized outbound HTTP connections to attacker-controlled infrastructure, using credential IDs the attacker obtained through a separate method to capture secrets stored in Jenkins. The attack requires high complexity - specifically, the attacker must pre-obtain valid Jenkins credential IDs via an independent channel before the CSRF vector becomes useful. No public exploit code exists and no active exploitation is confirmed; EPSS stands at 0.09% (0th percentile), reflecting negligible observed exploitation interest.

Cross-site request forgery in Jenkins Assembla Plugin 1.4 and earlier enables network-adjacent attackers to force an authenticated Jenkins user's session to initiate connections to attacker-controlled endpoints using attacker-supplied credentials. The plugin fails to validate CSRF tokens on its connection-triggering functionality, allowing external origins to forge legitimate-looking requests. No active exploitation has been identified (EPSS at 1st percentile, absent from CISA KEV), and SSVC assessment classifies exploitation as none with partial technical impact, placing this firmly in a lower remediation priority tier.

Jenkins Assembla Plugin 1.4 and earlier exposes a connection-test endpoint without adequate permission enforcement, allowing any Jenkins user holding only Overall/Read permission to trigger outbound HTTP connections to an arbitrary attacker-controlled URL with attacker-supplied credentials. This enables both a limited Server-Side Request Forgery (SSRF) vector for internal network probing and credential interception on the attacker's endpoint. No public exploit code or active exploitation has been identified at time of analysis; SSVC assessment confirms exploitation status as none.

XML external entity (XXE) injection in the Jenkins Assembla Plugin version 1.4 and earlier lets an attacker who can control the HTTP responses of the configured Assembla server read sensitive files and secrets from the Jenkins controller and pivot into internal services via server-side request forgery. Mapped to CWE-918 (SSRF) with a CVSS 3.1 base score of 7.1 (high), there is no public exploit identified at time of analysis and CISA SSVC rates exploitation as 'none' with only partial technical impact. Exploitation requires the attacker to influence what the Assembla endpoint returns, so it is a targeted rather than mass-exploitable condition.

Plaintext credential storage in Jenkins FitNesse Plugin 1.36 and earlier exposes job-level passwords to any user holding Extended Read permission or with direct access to the Jenkins controller filesystem via job config.xml files. The flaw (CWE-256) means credentials configured within FitNesse jobs are persisted unobfuscated on disk and retrievable through the Jenkins UI without requiring elevated administrative rights. No public exploit has been identified and EPSS sits at 0.17% (7th percentile), indicating low opportunistic exploitation activity, though the impact is meaningful in environments where FitNesse jobs store sensitive credentials.

Arbitrary code execution on the Jenkins controller affects the Jenkins OWASP ZAP Plugin version 1.0.7 and earlier, which incorrectly runs build operations on the controller node instead of the designated build agent. An attacker holding Item/Configure permission can leverage this misplaced execution to run arbitrary code in the security context of the controller, escaping agent isolation. No public exploit identified at time of analysis, and CISA SSVC records no known exploitation; EPSS is low at 0.39% (31st percentile).

Missing authorization in Jenkins MCP Server Plugin 0.177.v629fdb_2557fe and earlier exposes Pipeline replay scripts to users who hold only Item/Read permission. Authenticated Jenkins users can read replay script contents of any job they can see, potentially exposing sensitive pipeline logic, embedded credentials, or proprietary build configurations beyond what their permission level should allow. No active exploitation is confirmed (not in CISA KEV), no public exploit code has been identified, and the EPSS score of 0.17% (7th percentile) reflects minimal real-world exploitation interest at time of analysis.

Missing authorization checks in Jenkins Contrast Continuous Application Security Plugin 3.11 and earlier allow any authenticated Jenkins user with the low-privilege Overall/Read permission to enumerate the names of configured Contrast metadata via a network-accessible endpoint. The vulnerability is classified CWE-862 (Missing Authorization) and has an EPSS score of 0.15% (4th percentile), indicating negligible real-world exploitation activity. No public exploit code and no CISA KEV listing have been identified, making this a low-urgency but real information-disclosure concern for multi-tenant Jenkins environments with untrusted users.

Cross-site request forgery in Jenkins Contrast Continuous Application Security Plugin 3.11 and earlier allows a remote attacker to force a Jenkins instance to establish outbound connections to an arbitrary attacker-controlled URL, supplying attacker-chosen credentials including a username, API key, and service key. Any authenticated Jenkins user can be the unwitting victim if tricked into visiting a crafted page while logged in. No public exploit code or confirmed active exploitation has been identified at time of analysis, and SSVC rates exploitation likelihood as none with partial technical impact.

Missing authorization in Jenkins Contrast Continuous Application Security Plugin 3.11 and earlier permits any authenticated Jenkins user holding the minimal Overall/Read permission to invoke a connection test endpoint with fully attacker-controlled URL, username, API key, and service key. This enables the Jenkins server to make arbitrary outbound HTTP connections - a Server-Side Request Forgery (SSRF)-class impact - without the elevated privileges that should guard such functionality. No public exploit has been identified at time of analysis and EPSS sits at the 4th percentile, indicating low current exploitation probability despite network reachability.

Path traversal in the Jenkins External Workspace Manager Plugin (versions 1.3.2 and earlier) lets an attacker with Item/Configure permission supply traversal sequences in the custom workspace path of the exwsAllocate Pipeline step to read arbitrary files from the Jenkins controller filesystem, which the vendor notes can escalate to remote code execution. The flaw requires an authenticated low-privileged user (CVSS:3.1 PR:L, base 8.8) and is reported directly by the Jenkins security team. No public exploit identified at time of analysis, and CISA SSVC marks exploitation as none.

Cross-site request forgery in Jenkins EC2 Fleet Plugin versions through 4.2.3.539.v8fedff2a_81c3 enables a network attacker to force Jenkins to connect to an attacker-controlled endpoint using AWS credentials stored in Jenkins, effectively exfiltrating those credentials. All Jenkins instances with this plugin installed and AWS credentials configured are at risk. No active exploitation is confirmed (not in CISA KEV), SSVC rates this as non-automatable with partial technical impact, and no public exploit code has been identified at time of analysis.

Missing permission check in Jenkins EC2 Fleet Plugin versions up to 4.2.3.539.v8fedff2a_81c3 enables any authenticated user holding the low-privilege Overall/Read role to trigger a credential-capture attack by directing the plugin to connect to an attacker-controlled endpoint and transmitting AWS credentials stored in Jenkins. The attacker must independently obtain a valid credential ID before exploiting this flaw, making it a chained attack rather than a direct standalone exploit. No public exploit code has been identified at time of analysis and CISA has not added this to the KEV catalog; SSVC rates exploitation status as none.

Credential ID enumeration in Jenkins Gitee Plugin 1288.v18b_deb_c9069b_ and earlier allows authenticated attackers holding only global Item/Configure permission to bypass the intended per-job permission boundary and list credential IDs stored in Jenkins. The root cause is an incorrect permission check (CWE-862) that conflates global and job-scoped authorization, leaking credential identifiers without requiring job-level rights. No public exploit code exists and SSVC rates exploitation status as none; however, enumerated credential IDs can serve as reconnaissance for chained attacks targeting those credentials.

Cross-site request forgery in Jenkins Gitee Plugin 1288.v18b_deb_c9069b_ and earlier allows network-accessible attackers to force a Jenkins instance to initiate connections to attacker-controlled URLs, using credential IDs previously obtained through a separate method. The CVSS vector confirms a low-privileged authenticated attacker posture (PR:L), meaning the victim must hold an active Jenkins session. No active exploitation is confirmed per CISA KEV, and the SSVC framework rates exploitation as currently none with partial technical impact.

Missing permission checks in Jenkins Gitee Plugin 1288.v18b_deb_c9069b_ and earlier allow any authenticated user holding the minimal Overall/Read Jenkins role to trigger outbound connections from the Jenkins controller to an attacker-specified URL using credential IDs sourced through a secondary method. This creates an SSRF-like primitive enabling internal network probing and credential ID validation without administrative access. No public exploit code has been identified at time of analysis, and SSVC confirms current exploitation status as none.

Cross-site request forgery in Jenkins Priority Sorter Plugin 936.v2c01c6b_84449 and earlier enables a network-based attacker to overwrite global job priority configuration by luring an authenticated Jenkins user into triggering a forged HTTP request. Exploitation requires mandatory victim interaction and produces only limited integrity impact - no confidentiality or availability loss. No public exploit code exists, EPSS sits at the 1st percentile, and CISA SSVC records exploitation status as none, making this a low operational priority for most organizations.

Jenkins Bitbucket Push and Pull Request Plugin versions 3.3.8 and earlier unconditionally disables SSL/TLS certificate and hostname validation for all outbound Bearer token authenticated requests to configured Bitbucket Server endpoints, creating a man-in-the-middle exposure. Any attacker positioned to intercept network traffic on the path between the Jenkins controller and the Bitbucket Server can capture the Bearer token and subsequently authenticate directly to the Bitbucket Server API. No public exploit is identified at time of analysis, and SSVC rates exploitation as none with partial technical impact; however, the token capture risk is non-trivial for deployments routing Jenkins traffic over untrusted or shared network segments.

LDAP injection in Jenkins Active Directory Plugin 2.41.1 and earlier allows unauthenticated remote attackers to enumerate Active Directory entries and authenticate as any directory user they can identify via wildcard matching, provided they already know that user's password. The vulnerability is confined to the Windows native ADSI authentication path, limiting exposure to Jenkins instances running on Windows with ADSI configured. No public exploit code or active exploitation has been identified; SSVC rates it non-automatable with partial technical impact.

Jenkins Job Configuration History Plugin version 1356.ve360da_6c523a_ and earlier exposes encrypted secret values to any Jenkins user holding Extended Read permission by failing to apply Jenkins' standard secret redaction when rendering historical job and agent configurations. Encrypted credential values that Jenkins would normally mask are displayed in full within the plugin's history view, potentially enabling offline analysis of those values. No public exploit or active exploitation has been identified; SSVC rates this as non-automatable with partial technical impact.

Missing authorization in Jenkins Git Parameter Plugin 462.vdcf3df2ed2ca_ and earlier exposes SCM repository metadata - branch names, tag names, and revision data - to any Jenkins user holding only Item/Read permission. An authenticated low-privilege user can query this metadata from jobs they can read without possessing the additional permissions that should gate SCM enumeration. No active exploitation has been confirmed, EPSS probability is minimal at 0.21% (11th percentile), and SSVC rates exploitation as none - making this a low-priority information disclosure issue for most organizations.

Information disclosure in Jenkins GitHub Branch Source Plugin 1967.1969.v205fd594c821 and earlier exposes GitHub Enterprise server URLs to low-privileged users. Any Jenkins user holding the minimal Overall/Read permission can query the global plugin configuration and retrieve the URLs of all configured GitHub Enterprise servers, potentially revealing internal infrastructure topology. No active exploitation has been identified (SSVC: exploitation none; EPSS 0.21%, 11th percentile), and no public exploit code is known at the time of analysis.

The Pipeline Snippet Generator in Jenkins Pipeline: Groovy Plugin versions through 4331.v9d06ed4658ff fails to enforce type restrictions, enabling authenticated low-privilege users to instantiate arbitrary Java/Groovy types - including those governing job and system configuration - far beyond the intended scope of Pipeline step generation. Confirmed by the Jenkins security team under SECURITY-3677, this flaw could allow an internal attacker to access or manipulate configuration objects outside their authorized permission set. No public exploit code has been identified and CISA SSVC rates exploitation as none with no automatable path, placing this as a credible but lower-urgency remediation target.

Cross-site request forgery in the Jenkins Pipeline: Groovy Plugin (versions up to and including 4331.v9d06ed4658ff) enables authenticated low-privilege users to instantiate arbitrary Java types related to job or system configuration by exploiting the unprotected Pipeline Snippet Generator endpoint. The attacker can reach types outside the normally permitted set of Pipeline steps, potentially influencing configuration objects that should be off-limits at their privilege level. No public exploit code has been identified at time of analysis, and CISA SSVC rates exploitation as none with non-automatable delivery.

OS command injection in Jenkins Git Client Plugin 6.6.0 and earlier enables low-privileged authenticated attackers who can control a build's working directory name to execute arbitrary commands on the Jenkins agent. The plugin fails to escape the workspace directory path before embedding it into a dynamically generated SSH wrapper script, meaning shell metacharacters in the directory name are interpreted by the OS shell. No active exploitation is confirmed - EPSS is 0.18% (8th percentile) and SSVC exploitation status is 'none' - but the risk is meaningful in multi-tenant Jenkins environments where developers can define custom workspace names via Jenkinsfiles.

Sandbox escape in Jenkins Script Security Plugin 1402.v94c9ce464861 and earlier allows users permitted to run sandboxed Groovy scripts to execute arbitrary code outside the sandbox. The plugin fails to reject Groovy AST transformation annotations that carry an 'extensions' member, so an attacker can point that member at a suitable class already on the evaluating component's classpath and have it run outside sandbox restrictions. No public exploit identified at time of analysis, and SSVC exploitation status is 'none'; EPSS is low at 0.39%.

Sandbox bypass in the Jenkins Script Security Plugin (1402.v94c9ce464861 and earlier) lets users who can supply sandboxed Groovy scripts invoke arbitrary constructors, escaping the sandbox to run unrestricted code on the Jenkins controller. The flaw stems from the plugin failing to intercept implicit type casts on elements of typed for-each loops, a subtle gap in its interception logic. Reported by the Jenkins project (SECURITY-3792) with no public exploit identified at time of analysis; EPSS is low at 0.37% and CISA SSVC records no observed exploitation.

Stored XSS in allure-generator (versions <= 2.38.1) allows arbitrary JavaScript execution in the browser of anyone who views a generated Allure report containing crafted test result data. The vulnerable `ansi.js` Handlebars helper passes unsanitized `statusMessage` and `statusTrace` values - sourced from JUnit XML failure messages and equivalent fields in TRX, xUnit XML, xctest, and Allure 1/2 plugins - through `ansi-to-html` without HTML escaping, then wraps the output in `SafeString` to bypass Handlebars' auto-escape protection. A publicly available proof-of-concept demonstrates exploitation via a crafted JUnit XML file; the attack is particularly relevant to CI/CD environments (Jenkins, GitLab, GitHub Actions) where reports are served on shared infrastructure with active authenticated sessions.

Unencrypted secret storage in Jenkins 2.567 and earlier (LTS 2.555.2 and earlier) exposes credentials submitted via POST config.xml to any user holding Item/Extended Read permission or with read access to the Jenkins controller filesystem. Secrets that should be encrypted at rest are written as plaintext into job config.xml files, making them directly readable through Jenkins' built-in permission model or OS-level file access. No public exploit code has been identified and this CVE is not listed in the CISA KEV catalog, but the privileged insider and lateral-movement risk is significant for organizations embedding CI/CD credentials in job configurations.

Stored XSS in Jenkins 2.483-2.567 and LTS 2.492.1-2.555.2 allows attackers holding Agent/Configure permission to inject persistent malicious scripts via the `POST config.xml` API by supplying an unescaped generic offline cause description. When any Jenkins user views the affected agent page, the payload executes in their browser, enabling session hijacking or unauthorized actions within the Jenkins instance. No public exploit or CISA KEV listing has been identified, and EPSS probability is low at 0.02%, reflecting the constrained attack surface from the required permission prerequisite.

Open redirect in Jenkins 2.567 and earlier (LTS 2.555.2 and earlier) enables unauthenticated remote attackers to craft login URLs with a malicious external domain in the 'from' parameter under the 'Delegate to servlet container' security realm, silently redirecting authenticated users to attacker-controlled sites post-login for phishing purposes. The CVSS vector (PR:N, UI:R) confirms no attacker authentication is needed, but victim interaction is mandatory - the user must click a crafted link and complete a login. No public exploit identified at time of analysis and the vulnerability is not listed in CISA KEV; vendor-released patches are available as of 2026-06-10.

Missing authorization checks in Jenkins 2.567 and earlier (LTS 2.555.2 and earlier) expose user-specific configuration data to any authenticated user holding the Overall/Read permission. Authenticated low-privilege users can query the timezone setting of any Jenkins user account and enumerate the names of views configured within other users' 'My Views' personal dashboards, constituting an information disclosure weakness. No public exploit code exists and this CVE is not listed in the CISA KEV catalog at time of analysis, placing real-world risk in the low-moderate tier primarily relevant to multi-tenant or shared Jenkins deployments.

Missing authorization enforcement in Jenkins allows low-privileged authenticated users to cancel build queue items they lack permission to view. Affecting Jenkins 2.567 and earlier (LTS 2.555.2 and earlier), this CWE-862 flaw breaks the expected access control invariant that Item/Cancel should be constrained by Item/Read visibility. No public exploit code exists and this vulnerability is not listed in CISA KEV at time of analysis, but the low attack complexity and network accessibility make it a realistic threat in multi-tenant Jenkins deployments where fine-grained RBAC is in use.

Open redirect in Jenkins login flow enables phishing attacks by exploiting improper redirect URL validation. Tab or newline characters injected between `//` in a post-login redirect URL bypass Jenkins' legitimacy check, redirecting authenticated victims to attacker-controlled sites. Affects Jenkins weekly 2.567 and earlier and LTS 2.555.2 and earlier; vendor-released patches are available. No public exploit identified at time of analysis, and no CISA KEV listing exists, but the bypass technique is trivially derivable from the public advisory.

Open redirect exploitation in Jenkins allows unauthenticated network attackers to craft login URLs that bypass the post-authentication redirect validation and forward users to attacker-controlled external sites. Affected are Jenkins weekly releases through 2.567 and LTS releases through 2.555.2, where the redirect URL legitimacy check fails when the URL contains relative path segments such as `./` or `../`. No active exploitation is confirmed (not listed in CISA KEV) and no public exploit code has been identified at time of analysis, placing this in a moderate-risk, phishing-enablement category rather than a direct system compromise class.

Authenticated remote code execution in Jenkins 2.567 and earlier (LTS 2.555.2 and earlier) allows attackers with permission to submit config.xml to trigger deserialization of arbitrary core or plugin types that subsequently handle HTTP requests, enabling user impersonation, Script Console abuse, and arbitrary file reads from the controller. The flaw is tracked as a CWE-502 unsafe deserialization issue with a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit identified at time of analysis, but the vendor (Jenkins project) has issued a coordinated advisory and patched releases.

Server-side request forgery (SSRF) in hekmon8/Jenkins-server-mcp 0.1.0 allows a remote, low-privileged attacker to forge outbound HTTP requests from the server by manipulating the jobPath parameter across the get_build_status, get_build_log, and trigger_build functions in src/index.ts. The flaw stems from absent or insufficient validation of user-supplied job path values before they are used to construct server-side requests to Jenkins. Publicly available exploit code exists (disclosed via GitHub issue #4); no vendor patch has been released and the maintainer has not responded to the disclosure.

Incorrect authorization in Apache ActiveMQ Artemis allows authenticated STOMP protocol clients to modify address routing-type settings without sufficient privilege checks. Affects Artemis versions through 2.44.0 and 2.53.0 respectively, the flaw (CWE-863) permits low-privileged network users to alter broker address routing configuration, impacting message routing integrity. No public exploit code has been identified at time of analysis, and CISA KEV listing is absent, placing this in a monitor-and-patch priority tier rather than emergency response.

Cross-site request forgery in Jenkins Multijob Plugin versions up to and including 662.vd2e0001f6b_b_d enables unauthenticated remote attackers to resume failed Multijob builds by tricking an authenticated Jenkins user into issuing a forged request. The CVSS vector (PR:N/UI:R) confirms no attacker privileges are required, but victim interaction is mandatory, limiting scalability. No public exploit code and no active exploitation have been identified at time of analysis; SSVC independently corroborates Exploitation: none.

Stored cross-site scripting in Jenkins buildgraph-view Plugin 1.8 and earlier allows authenticated attackers with job or view configuration privileges to inject persistent malicious scripts via an unescaped build URL. Any Jenkins user who subsequently views the affected build graph page triggers execution of the attacker-controlled script in their browser context. No active exploitation is confirmed (not in CISA KEV) and no public exploit code is known; SSVC rates exploitation status as none with partial technical impact.

Jenkins Job Import Plugin version 143.v044a_2e819b_27 and earlier exposes credentials ID enumeration to any authenticated user holding the minimal Overall/Read permission due to a missing permission check on an HTTP endpoint. Any low-privileged Jenkins user can query this endpoint and retrieve the IDs of all credentials stored in the Jenkins credentials store, enabling reconnaissance for follow-on credential-targeting attacks. No public exploit has been identified at time of analysis, CISA has not listed this in KEV, and SSVC rates exploitation status as none with partial technical impact.

Cross-site request forgery in Jenkins GitHub Integration Plugin 0.7.3 and earlier allows unauthenticated remote attackers to trigger unauthorized pull request builds by tricking an authenticated Jenkins user into visiting a crafted page. The vulnerability stems from missing CSRF token validation on the endpoint that triggers pull request builds. With CVSS 4.3 (Medium) and no public exploit or KEV listing identified at time of analysis, this represents a moderate-integrity risk primarily in CI/CD pipeline environments where unauthorized build execution could be leveraged for resource abuse or workflow manipulation.

Open redirect vulnerability in Jenkins Bitbucket OAuth Plugin 0.17 and earlier enables unauthenticated network attackers to craft login URLs that redirect authenticated victims to arbitrary, attacker-controlled destinations, facilitating phishing campaigns targeting Jenkins users. The plugin fails to validate or restrict the post-login redirect URL parameter, classified under CWE-601. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis; the CVSS 4.3 Medium rating reflects network reachability offset by a mandatory user interaction requirement.

Missing permission check in Jenkins AppSpider Plugin 1.0.17 and earlier allows any authenticated user with Overall/Read permission to force the Jenkins server to initiate connections to arbitrary attacker-specified URLs via a form validation endpoint. This constitutes a server-side request forgery (SSRF)-class primitive - an attacker can leverage this to probe internal network services, perform port scanning, or interact with internal infrastructure reachable by the Jenkins host. No public exploit has been identified at time of analysis, and CISA SSVC assessment confirms no active exploitation.

Arbitrary file write in the Jenkins Credentials Binding Plugin (version 720.v3f6decef43ea_ and earlier) lets users who can supply file or zip-file credentials to a job write files to attacker-chosen paths on the node filesystem, escalating to remote code execution when Jenkins is configured to let a low-privileged user configure such credentials for a job running on the built-in node. The flaw stems from missing file-name sanitization on the file and zip credential types. Rated CVSS 7.5 with high attack complexity (AC:H); no public exploit identified at time of analysis and the issue is not in CISA KEV.

Arbitrary file read on the Jenkins controller is possible in the Jenkins 'Pipeline: Groovy Libraries Plugin' (version 797.v90ea_a_9b_e45a_0 and earlier), where the plugin fails to prohibit symbolic links inside shared libraries. An attacker who can control the contents of a shared library consumed by a Pipeline job can plant symlinks that resolve to sensitive files (credentials, secrets, configuration) on the controller filesystem and exfiltrate them through the build. There is no public exploit identified at time of analysis, and SSVC marks exploitation status as none, so this is a patch-and-move-on issue rather than an active-exploitation emergency.

Arbitrary file disclosure in the Jenkins Email Extension Plugin (email-ext) versions 1933.v45cec755423f and earlier lets users who can control email content abuse the data-inline image attribute to supply file: URLs, causing the Jenkins controller to read local files and embed their contents as base64 inside outgoing emails. An authenticated attacker with rights to edit job email configuration or templates (CVSS PR:L) can exfiltrate controller secrets, credentials, and configuration. There is no public exploit identified at time of analysis and CISA's SSVC rates exploitation as none, but the CVSS 8.8 score and 'total' technical impact make controller secret theft a serious concern in shared Jenkins environments.

Unsafe deserialization in Jenkins Active Directory Plugin 2.41 and earlier allows a remote attacker holding administrative credentials to achieve full system compromise by manipulating the LDAP referral processing path. The plugin deserializes data received from LDAP referrals without validation (CWE-502), which can enable arbitrary code execution on the Jenkins controller. No public exploit exists at time of analysis, and CISA SSVC assesses this as not automatable, though technical impact is rated total - making it a targeted rather than opportunistic threat.

Server-Side Request Forgery in Jenkins Active Directory Plugin 2.41 and earlier enables a highly privileged attacker to abuse the plugin's default LDAP referral-following behavior to force Jenkins to issue out-of-band requests to attacker-controlled or internal network hosts. The vulnerability (CWE-918) stems from the plugin not restricting LDAP referrals by default, which can be weaponized to pivot from the Jenkins server into internal infrastructure. No public exploit code exists and SSVC confirms no known active exploitation, but the technical impact is rated total - confidentiality, integrity, and availability are all at risk if exploitation succeeds.

Jenkins LDAP Plugin versions up to and including 807.v7d7de30930cf deserializes Java objects returned via LDAP referral responses without any validation, exposing the underlying Jenkins instance to potential remote code execution via classic Java deserialization gadget chains. Exploitation is constrained by a high privilege requirement and high attack complexity (CVSS PR:H/AC:H), limiting realistic scenarios to attackers who already hold Jenkins administrative credentials or can manipulate LDAP referral destinations. No public exploit code has been identified and this vulnerability does not appear in the CISA KEV catalog at time of analysis.

Unconstrained LDAP referral following in Jenkins LDAP Plugin (≤ 807.v7d7de30930cf) enables Server-Side Request Forgery, allowing a highly privileged attacker who controls LDAP configuration to force the Jenkins server to initiate connections to arbitrary internal hosts by supplying a malicious LDAP server that returns crafted referrals. The CVSS score of 6.6 reflects genuine constraints: network-reachable but requiring both high privileges and high attack complexity, with High confidentiality, integrity, and availability impact if those barriers are cleared. SSVC assessment confirms no current exploitation and a non-automatable attack path, though technical impact is rated total; no public exploit code has been identified at time of analysis.

Cookie leakage in curl (libcurl) versions 7.71.0 through 8.19.0 allows remote servers to receive cookies intended for a different host when a stale custom cookie host value persists across requests. The flaw, tracked as CWE-319 (cleartext transmission of sensitive information), carries a CVSS 7.5 and SSVC 'partial' technical impact, with no public exploit identified at time of analysis and an EPSS of 0.01%.

Cross-proxy Digest authentication state leak in curl allows remote attackers to obtain sensitive authentication credentials when curl is used with proxy authentication across multiple proxy hops. The vulnerability affects curl versions from 7.12.0 through 8.19.0 due to improper handling of Digest authentication state between proxies, enabling credential disclosure with network-level access and no authentication requirements. EPSS score of 0.03% suggests low real-world exploitation probability despite the information disclosure impact.

Open redirect in the Jenkins Microsoft Entra ID Plugin (formerly Azure AD Plugin) version 666.v6060de32f87d and earlier allows network-accessible phishing attacks against Jenkins users. The plugin fails to validate the post-login redirect URL, enabling an attacker to craft a legitimate-looking Jenkins authentication link that silently forwards victims to an attacker-controlled site after successful Entra ID login. No active exploitation is confirmed (SSVC: none; EPSS 0.03%, 8th percentile), and the vendor has released a patch per the April 2026 Jenkins security advisory.

Stored cross-site scripting in Jenkins HTML Publisher Plugin (versions 427 and earlier) lets an attacker with Item/Configure permission inject JavaScript via an unescaped job name and URL written into the legacy wrapper file, which then executes in the browser of any user who later views the published report. There is no public exploit identified at time of analysis and EPSS is very low (0.04%, 12th percentile), but the SSVC technical impact is rated total, meaning a successful payload can fully compromise a victim session such as an administrator's.

Stored cross-site scripting in the Jenkins GitHub Plugin (versions ≤ 1.46.0) lets a low-privileged authenticated user with Overall/Read permission inject JavaScript by controlling the current job URL, which is unsafely embedded into the client-side validation logic for the 'GitHub hook trigger for GITScm polling' feature. When another user — potentially a Jenkins administrator — views the affected page, the attacker's script executes inside their authenticated Jenkins session. No public exploit is identified at time of analysis and EPSS is very low (0.04%), but the CVSS 9.0 rating and scope-changed impact make it a meaningful CI/CD privilege-escalation surface.

Missing authorization (CWE-862) in Jenkins GitHub Branch Source Plugin 1967.vdea_d580c1a_b_a_ and earlier allows any authenticated user with only Overall/Read permission to force the Jenkins server to initiate outbound connections to an arbitrary attacker-controlled URL using attacker-supplied GitHub App credentials. This SSRF-adjacent capability enables abuse of Jenkins as an unauthorized network proxy and may expose internal network topology to external actors. No public exploit has been identified and CISA has not added this to the KEV catalog; EPSS of 0.03% (7th percentile) and SSVC exploitation status of 'none' confirm low near-term exploitation likelihood, though the low privilege barrier makes it accessible to any credentialed Jenkins user.

Unsafe deserialization in Jenkins Matrix Authorization Strategy Plugin versions 2.0-beta-1 through 3.2.9 allows an authenticated user with Item/Configure permission to instantiate arbitrary Java classes from the Jenkins classpath by specifying class names in job configuration. The vulnerability arises because the plugin invokes parameterless constructors of user-specified classes when deserializing inheritance strategies without type restriction. No public exploit is identified at time of analysis, and SSVC signals exploitation as none, but the real-world impact depends on the richness of the Jenkins classpath - gadget classes available in that environment determine the attacker's effective reach.

Arbitrary file write in the Jenkins Credentials Binding Plugin (version 719.v80e905ef14eb_ and earlier) allows an authenticated user who can supply file or zip file credentials to a job to escape the intended credentials directory via unsanitized file names (path traversal), planting files anywhere on the node filesystem. When Jenkins is configured to let a low-privileged user configure such credentials for a job running on the built-in node, this file write escalates to remote code execution. There is no public exploit identified at time of analysis, and EPSS is low (0.34%, 57th percentile), consistent with the high attack complexity and non-default preconditions.

Jenkins Script Security Plugin versions up to and including 1399.ve6a_66547f6e1 expose classpath enumeration to any user holding the low-privilege Overall/Read permission due to a missing authorization check (CWE-862). Any authenticated Jenkins user can query pending and approved Script Security classpaths without elevated rights, leaking internal class names, library paths, and approved script configuration useful for targeted reconnaissance. No public exploit exists and EPSS sits at 0.03% (7th percentile), placing this firmly in the low-urgency tier despite its network-reachable vector.

Path traversal in Allure report generator for Jenkins allows unauthenticated attackers to read arbitrary files from the host system by crafting malicious test result files with specially crafted attachment paths. The vulnerability stems from insufficient path validation when processing attachments during report generation, enabling sensitive files to be included in generated reports. A patch is not currently available.

The Jenkins LoadNinja Plugin version 2.1 and earlier fails to mask LoadNinja API keys displayed on the job configuration form, allowing attackers with access to the Jenkins web interface to observe and capture sensitive credentials. This information disclosure vulnerability affects Jenkins administrators and users with job configuration visibility, enabling credential theft that could lead to unauthorized access to LoadNinja services and associated testing infrastructure. No CVSS score, EPSS data, or active exploitation status (KEV listing) is currently available in public sources.

The Jenkins LoadNinja Plugin versions 2.1 and earlier stores LoadNinja API keys in plaintext within job configuration files (config.xml) on the Jenkins controller, allowing unauthorized disclosure of sensitive credentials. Users with Item/Extended Read permission on Jenkins jobs or direct file system access to the controller can extract these API keys, potentially leading to account compromise and unauthorized access to LoadNinja services. This is a straightforward credential exposure vulnerability with no complexity barriers to exploitation once access is gained.