Apache

phpSysInfo up to and including version 3.4.5 exposes a complete IP allowlist bypass in read_config.php that any unauthenticated remote attacker can exploit by sending a spoofed X-Forwarded-For or Client-IP HTTP header set to any address present in the PSI_ALLOWED configuration. The flaw (CWE-290) renders the application's only access-control mechanism entirely ineffective, allowing full retrieval of system telemetry including hostname, kernel version, CPU model, memory layout, filesystems, and network interface addresses. A working proof-of-concept is publicly available on Exploit-DB; no CISA KEV listing exists at time of analysis.

Denial-of-service in Spring for Apache Kafka's `DeadLetterPublishingRecovererFactory` exposes consumer JVMs across all supported branches (2.8.x through 4.1.0) to crash or hang when processing messages with a crafted `retry_topic-original-timestamp` header. An authenticated Kafka producer can inject a ConsumerRecord carrying an oversized or malformed header byte array, which is passed without any length or format validation directly to Java's `BigInteger(byte[])` constructor, triggering heap memory exhaustion or an unhandled exception that disrupts message consumption. No public exploit code has been identified and the CVE does not appear in CISA KEV at time of analysis, but low attack complexity combined with broad version coverage makes this a credible availability threat for any Spring Kafka deployment using retry or dead-letter queue features.

Header type injection in Spring for Apache Kafka's default mapper configuration allows any Kafka producer with access to a consumed topic to inject java.net.InetAddress objects through the spring_json_header_types message header, triggering DNS resolution on the consumer host. All applications using @KafkaListener with the default JsonKafkaHeaderMapper or DefaultKafkaHeaderMapper - spanning versions 2.8.x through 4.1.0 - are affected without any non-default configuration required. No public exploit code has been identified at time of analysis, and the CVE is not listed in CISA KEV.

LDAP injection in Apache APISIX's ldap-auth plugin allows a caller holding valid credentials for any LDAP directory entry to authenticate to the gateway as a different consumer - including entries outside the subtree the plugin was configured to restrict access to. Affected versions span 2.11.0 through 3.17.0, covering several years of releases. No public exploit code or active exploitation has been identified at time of analysis, but the primitive (credential-bearing lateral identity escalation at the API gateway layer) is high-value in multi-tenant or zero-trust deployments.

CPU exhaustion via algorithmic complexity in Apache APISIX 3.17.0 allows unauthenticated remote attackers to pin a gateway worker process at 100% CPU using a single small HTTP request targeting routes protected by the graphql-limit-count plugin. The CVSS 4.0 score of 8.7 reflects the high availability impact and trivial exploitation requirements - no authentication, no complexity, no user interaction. No public exploit code or CISA KEV listing has been identified at time of analysis, though the minimal attack payload described makes this class of vulnerability straightforward to weaponize once the affected plugin is known to be in use.

Response poisoning in Apache APISIX 2.12.0 through 3.17.0 enables remote attackers to manipulate the gateway's serverless plugin routes so that victims receive attacker-chosen content or other authenticated users' API responses. The root cause is inconsistent HTTP request boundary interpretation - the defining characteristic of HTTP Request/Response Smuggling - applied within APISIX's serverless plugin execution pipeline. No public exploit has been identified at time of analysis, and vendor-released patch version 3.18.0 is available.

Authorization bypass and privilege escalation in Apache APISIX 3.11.0-3.17.0 stem from the `attach-consumer-label` plugin failing to strip client-supplied consumer-label headers before using them in security decisions. An attacker who can reach the gateway can forge header values to impersonate a higher-privileged consumer label, bypassing route-level access controls. No vendor-released patch is available at time of analysis (fix version marked pending); no public exploit code or CISA KEV listing has been identified.

Insufficient session expiration in Apache Tomcat allows an authenticated attacker to maintain an active WebSocket connection after the underlying HTTP session has been invalidated, violating the Jakarta WebSocket specification's requirement that WebSocket sessions close when their parent HTTP session ends. Affected are all supported branches from 9.0.0.M1 through 9.0.120, 10.1.0-M1 through 10.1.57, and 11.0.0-M1 through 11.0.24, plus EOL branches 7.0.43-7.0.109 and 8.5.0-8.5.100. No public exploit or CISA KEV listing has been identified at time of analysis, and the low EPSS score (0.28%, 19th percentile) reflects limited real-world exploitation probability.

Uncontrolled resource consumption in Apache Tomcat's HTTP/2 implementation allows remote unauthenticated attackers to exhaust server memory by repeatedly opening and resetting HTTP/2 streams, exploiting an allocation leak in the backlog tracking mechanism that fails to release memory on stream reset. Affected branches span Tomcat 9.0.39-9.0.120, 10.1.0-M1-10.1.57, and 11.0.0-M1-11.0.24, with EOL branch 8.5.59-8.5.100 also confirmed vulnerable but unpatchable. No public exploit has been identified at time of analysis; EPSS stands at a low 0.22%, but the unauthenticated network vector and high availability impact make this operationally significant for any HTTP/2-enabled Tomcat deployment.

Improper Authentication in Apache Tomcat allows a remote, low-privileged attacker to gain authenticated access to applications even when the presented identity does not exist in the configured DataSourceRealm. The flaw is triggered specifically under CLIENT-CERT or SPNEGO authentication schemes, causing Tomcat to grant a session to a non-existent user. No public exploit or CISA KEV listing is present at time of analysis, but the CVSS C:H/I:H impact rating reflects the potential to fully compromise protected application resources if exploited in matching deployments.

Authorization bypass in Apache Tomcat's FORM-based authentication lets attackers reach protected resources that a security constraint was meant to restrict, defeating rules that grant a role POST access but withhold GET (or vice versa) on the same URL. It affects Tomcat 11.0.0-M1 through 11.0.24, 10.1.0-M1 through 10.1.57, 9.0.0.M1 through 9.0.120, plus EOL 8.5.0-8.5.100 and 7.0.0-7.0.109. There is no public exploit identified at time of analysis, and EPSS is low (0.28%), but CISA SSVC rates the technical impact as total and the attack as automatable.

Improper Authorization in Apache Tomcat causes security-role-ref mappings - intended only for servlet-level isUserInRole() checks - to be incorrectly applied as role aliases within the Realm's authorization logic, allowing authenticated low-privileged users to access resources protected by higher-privileged roles. Supported branches 9.0.25-9.0.120, 10.1.0-M1-10.1.57, and 11.0.0-M1-11.0.24 are confirmed affected, along with EOL branches 7.0.97-7.0.109 and 8.5.46-8.5.100. No public exploit identified at time of analysis, and EPSS probability stands at 0.20% (10th percentile), though the CVSS 8.1 score reflects meaningful integrity and availability exposure in deployments relying on Realm-enforced role separation.

Rewrite valve processing in Apache Tomcat contains an off-by-one error (CWE-193) in the handling of the [N] (Next) flag, causing rule iteration to restart from the second rewrite rule instead of the first, which can produce unintended looping behavior and result in a denial-of-service condition. Affected supported versions span Tomcat 9.0.0.M1 through 9.0.120, 10.1.0-M1 through 10.1.57, and 11.0.0-M1 through 11.0.24; the EOL 8.5.x branch is also affected but will not receive a fix. No active exploitation is confirmed (not in CISA KEV), EPSS stands at 0.20% (10th percentile), and no public exploit code has been identified at time of analysis.

Authentication bypass in Apache Tomcat's DIGEST authenticator lets a network attacker who has captured a valid DIGEST-authenticated request replay it once when its nonceCount sits on the upper boundary of the replay window and fewer than windowSize requests have since been made. It affects Tomcat 11.0.0-M1 through 11.0.24, 10.1.0-M1 through 10.1.57, 9.0.0.M1 through 9.0.120, plus EOL 8.5.x and 7.0.x branches, but only where DIGEST authentication is actually enabled. No public exploit identified at time of analysis; EPSS is low at 0.28% (20th percentile), so the assigned 9.8 overstates practical risk.

Improper input validation in Apache Tomcat 9.0.115-9.0.120, 10.1.53-10.1.57, and 11.0.20-11.0.24 stems from an incomplete fix for CVE-2026-32990 and, per its CVSS:3.1 vector, permits remote unauthenticated attackers to compromise confidentiality, integrity, and availability of the servlet container. Reported by the Apache security team, it carries a critical 9.8 base score, though vendor tagging labels the impact as Information Disclosure, which is narrower than the vector implies. No public exploit identified at time of analysis, and EPSS estimates exploitation probability at just 0.21% (11th percentile).

Apache Tomcat's Unix domain socket creation path exposes a TOCTOU race condition across versions 9.0.42-9.0.120, 10.1.0-M1-10.1.57, and 11.0.0-M1-11.0.24, enabling an unauthorized local OS user to seize the socket before Tomcat finalizes access permissions. The vendor-assigned CVSS 8.1 with AV:N directly conflicts with the description's explicit 'local user' constraint and the inherently host-local nature of Unix domain sockets - the effective attack surface is limited to users with OS-level access on Tomcat hosts. No public exploit code or active exploitation has been identified; EPSS sits at 0.16% (5th percentile), indicating negligible real-world exploitation pressure at time of analysis.

Security constraint bypass in Apache Tomcat (7.0.x through 11.0.x) lets remote unauthenticated attackers reach protected resources when a broader security constraint for a longer path is declared ahead of a more restrictive constraint for a shorter sub-path, causing the wrong constraint to be applied. The flaw (CVSS 9.1, CWE-284) exposes access-controlled application paths without valid credentials. No public exploit identified at time of analysis, and EPSS is low (0.23%), but the network-reachable, no-interaction profile makes it a meaningful patch priority.

SQL injection in the Apache Hive Metastore (versions 4.0.0 through 4.2.0) lets a caller who can invoke partition-name Metastore RPCs manipulate the generated WHERE clause so operations intended for one partition match additional rows in the same table. Because client-supplied partition names are concatenated into direct-SQL statements instead of bound as parameters, a crafted name containing a single quote can redirect reads, statistics updates, truncate/drop targets, and file-metadata cache operations to unintended partitions. No public exploit is identified at time of analysis and the flaw is not in CISA KEV; the input assigns CVSS 9.8, but the vendor description constrains impact to partition targeting within referenceable tables rather than arbitrary cross-database access.

Server-side request forgery in Apache Hive versions 2.1.0 through 4.2.0 lets an authenticated user with CREATE TABLE rights coerce the HiveServer2/Metastore process into fetching an attacker-chosen URL by planting a crafted avro.schema.url table property on an Avro table that is later queried. The fetch runs with the Hive service identity, exposing cloud instance metadata (e.g. 169.254.169.254), internal-only network services, and local files. No public exploit is identified at time of analysis and EPSS is low (0.29%), but the CVSS 9.1 rating and low attack complexity make it a meaningful post-authentication risk; upgrade to 4.2.1 resolves it.

Authentication bypass in Apache HiveServer2 4.0.0-4.2.0 allows unauthenticated network attackers to impersonate any Hive user and obtain a fully authenticated HiveServer2 session when SAML mode is enabled over HTTP transport. The root cause is an inverted HMAC signature comparison in HiveSamlAuthTokenGenerator.java - the original code used !MessageDigest.isEqual(), causing all tokens to pass validation regardless of signature correctness, meaning a forged bearer token with any embedded username is unconditionally accepted. No CISA KEV listing and an EPSS of 0.14% (4th percentile) indicate no confirmed active exploitation at time of analysis, but the logic flaw is trivially exploitable once the deployment condition is met.

Unrestricted Solr query syntax passthrough in the TYPO3 EXT:solr enterprise search extension exposes indexed data to remote unauthenticated attackers via blind injection techniques. By crafting queries that exploit Solr's native field selectors, wildcards, and range operators, an attacker can enumerate schema field names and systematically extract stored values without triggering obvious errors. No public exploit code has been identified at time of analysis; the CVSS 4.0 score of 6.3 reflects high attack complexity (AC:H/AT:P) that limits opportunistic mass exploitation.

Unauthenticated REST API disclosure in Apache Allura through version 1.19.1 exposes certain content items to unauthorized actors without any credentials. The vulnerability stems from insufficient access control on REST endpoints, allowing any network-accessible client to retrieve content that should require authentication. No public exploit or CISA KEV listing has been identified at time of analysis, but the low exploitation barrier (unauthenticated, network-accessible) makes this a straightforward information leakage risk for any publicly exposed Allura instance.

Header-filter bypass in the Apache Camel Undertow component (4.11.0-4.14.8, 4.15.0-4.18.3, and 4.19.0-4.21.x) lets remote senders smuggle legacy 'websocket.' dispatch headers across the undertow transport boundary. Because UndertowEndpoint overwrote the UndertowHeaderFilterStrategy with the base HttpHeaderFilterStrategy, undertow-specific filtering never ran on endpoint-configured routes, so an undertow HTTP consumer maps attacker-controlled 'websocket.*' wire headers onto the Exchange and a downstream undertow WebSocket producer can be steered to deliver to a peer other than the one the route selected. No public exploit identified at time of analysis, EPSS is low (0.16%, 5th percentile), and the fix is available from Apache.

Header-injection in the Apache Camel camel-atmosphere-websocket producer lets an external sender hijack WebSocket message dispatch in routes that bridge an HTTP consumer into the producer. Because the dispatch headers (websocket.connectionKey, websocket.connectionKey.list, websocket.sendToAll, websocket.eventType, websocket.errorType) use dotted names outside the filtered Camel namespace, the inherited HttpHeaderFilterStrategy admits them in both directions, so an attacker-supplied header overrides the recipient the route selected - suppressing a notification meant for one client or redirecting it to another client whose connection key the sender knows. No public exploit identified at time of analysis; EPSS is low (0.23%, 13th percentile) and it is not in CISA KEV, though the vendor rates it CVSS 9.8.

Header injection via structured-mode CloudEvents in Apache Camel's Knative consumer enables unauthenticated SSRF, path traversal, and message-dispatch redirection against routes that forward to header-driven components. The flaw exists because CloudEvent extension fields in structured content mode (Content-Type: application/cloudevents+json) are copied directly into Camel Exchange headers without applying the KnativeHttpHeaderFilterStrategy that correctly guards the binary content-mode path - an incomplete fix of the same filter-bypass pattern addressed across multiple related CVEs (CVE-2025-27636, CVE-2025-29891, CVE-2025-30177, CVE-2026-40453, CVE-2026-47323). No public exploit or CISA KEV listing has been identified at time of analysis, but the attack surface - unauthenticated HTTP POST to a Knative endpoint - requires no special tooling.

JWT claim validation in Apache Camel's Platform HTTP Main component silently fails to enforce issuer and audience constraints when neither jwtIssuer nor jwtAudience is configured, causing the embedded Vert.x HTTP server to accept any unexpired token signed by any key in the trusted keystore. Affected are Apache Camel versions 4.8.0 through 4.21.x across both the application server and management server paths. An attacker who possesses a valid JWT from any identity provider trusted by the configured keystore - such as a token legitimately issued for a different service in a shared IdP environment - can authenticate to the Camel HTTP endpoints without holding credentials intended for that service. No public exploit has been identified at time of analysis, and CISA KEV listing is absent.

Arbitrary file write via path traversal in the Apache Camel Google Cloud Storage consumer component affects versions 4.0.0 through 4.21.x, allowing anyone who can influence GCS bucket object names to cause the Camel process to create or overwrite files outside the configured download directory. The consumer appends blob names verbatim to the local path using the unsanitized ${file:name} token without directory containment checks, and the filter option that could restrict object names is disabled by default. No public exploit is identified at time of analysis; SSVC rates the flaw automatable once malicious object names are present in the consumed bucket, and vendor-released patches are available at 4.14.9, 4.18.4, and 4.22.0.

Arbitrary file write via path traversal in the Apache Camel camel-azure-storage-blob component lets an attacker who can influence blob names in a consumed Azure Storage container force Camel to create or overwrite files outside the configured download directory, with the privileges of the Camel process. It affects Apache Camel 4.0.0 before 4.14.9, 4.15.0 before 4.18.4, and 4.19.0 before 4.22.0, where BlobOperations.downloadBlobToFile joined the fileDir option with the raw remote blob name without normalization or containment checks. No public exploit has been identified at time of analysis and the CVSS is 9.1, but EPSS is low (0.18%, 7th percentile), indicating no observed exploitation activity yet.

Path traversal in Apache Camel's camel-azure-storage-datalake component allows anyone with write access to a consumed Azure Data Lake Storage Gen2 filesystem to direct the Camel process to write or overwrite files at arbitrary locations on the local filesystem. The downloadToFile operation constructs local paths by joining the configured fileDir with the remote file name exactly as returned by the Azure SDK - without lexical normalization or any boundary check - meaning a remote path name containing parent-directory segments (e.g., '../../etc/cron.d/payload') resolves outside fileDir. Depending on what the Camel process can write, this integrity violation can escalate to code execution or service disruption. No active exploitation has been identified at time of analysis, and vendor-released patches are available in versions 4.14.9, 4.18.4, and 4.22.0.

MIME header injection in Apache Camel's camel-mail MimeMultipart data format allows unauthenticated network senders to plant Camel-internal namespace headers onto the Camel Exchange when headersInline is set to true, potentially redirecting what downstream route components - such as camel-sql - execute. Versions 2.17.0 through 4.14.8, 4.15.0 through 4.18.3, and 4.19.0 through 4.21.x are affected across all release lines until the current fixes. No public exploit code or active exploitation has been identified; EPSS sits at 0.16% and SSVC rates exploitation status as none, making this a patch-priority rather than emergency-response item for most organizations.

Heap exhaustion via unbounded memory leak in micrometer-core affects Java applications using Apache HttpAsyncClient (4.x or 5.x) instrumented with MicrometerHttpClientInterceptor. When asynchronous HTTP requests fail before receiving any server response - due to connection resets, network timeouts, or unreachable endpoints - the per-request tracking state allocated by the interceptor is never released, accumulating indefinitely on the JVM heap. Sustained failure conditions (such as a misbehaving or attacker-controlled upstream server) can drive heap exhaustion to OutOfMemoryError, crashing the instrumented application. No public exploit identified at time of analysis, and the vulnerability is not listed in CISA KEV.

Session cookie forgery in Apache::AppSamurai::Util through version 1.01 is possible because CreateSessionAuthKey derives its entire entropy from observable runtime state - wall-clock microseconds and the Apache worker process ID - rather than a cryptographically secure random source. An unauthenticated remote attacker who can bound the second in which a target session was created and enumerate the small PID space can construct candidate 64-character hex cookies and recover a valid session token through online brute-force, bypassing authentication for all resources protected by the module. No public exploit code has been identified and SSVC confirms no current exploitation, though the attack is mechanically feasible given the constrained key space.

Out-of-bounds read and one-byte out-of-bounds write in mod_auth_openidc's state-cookie parser (all versions prior to 2.4.19.4) allow unauthenticated remote attackers to crash Apache worker processes by sending a malformed Cookie header. The root cause is a loop termination condition in src/state.c that checked whether a pointer was NULL — a condition that could never fire since the pointer is only ever incremented — rather than checking for the string terminator, causing state-prefixed cookie tokens lacking '=' to scan and write past the end of the token buffer. No CISA KEV listing or confirmed public exploit exists at time of analysis, but the CVSS AV:N/AC:L/PR:N profile and the fully transparent fix commit make this trivially automatable for denial-of-service once widely known.

Resource exhaustion in Apache CloudStack's scoped global configuration subsystem-spanning versions 4.7.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0-allows authenticated low-privilege users to gradually trigger a denial-of-service condition against the management server. The vulnerability (CWE-772) affects multiple plugins including Quota and Host-HA, which allocate resources during configuration operations but fail to release them after their effective lifetime. No public exploit or active exploitation has been identified; vendor-released fixes are available in 4.20.3.1 and 4.22.1.1.

Argument injection in Apache InLong's Agent Installer (versions 2.0.0 through 2.3.x) enables arbitrary shell command execution via the ModuleManager's ExcuteLinux.exeCmd() method, which applies no input filtering or whitelist validation. Any deployment running InLong agents within the affected version range is exposed to OS-level command execution on the agent host system. Apache has released version 2.4.0 as the authoritative fix; no public exploit has been identified at time of analysis.

OS command injection in Apache CloudStack's NAS backup provider plugin enables an authenticated operator account to execute arbitrary commands on KVM hypervisor hosts by supplying unsanitized shell metacharacters to the addBackupRepository or updateBackupRepository management APIs. Affected deployments span versions 4.20.0.0 through 4.22.1.0 when the NAS backup provider plugin is in use; exploitation is deferred and triggered when any downstream account performs a backup restore. No public exploit has been identified at time of analysis, and CISA SSVC rates exploitation status as 'none,' though technical impact is rated 'total' given hypervisor-level code execution.

Cross-tenant root command execution in Apache CloudStack (4.14.0.0-4.20.3.0 and 4.21.0.0-4.22.1.0) allows an authenticated tenant holding only the default User role to run arbitrary shell commands as root on the KVM hypervisor host, which also runs other tenants' VMs. The flaw stems from CloudStack fetching a user-supplied .metalink file during directDownload template registration and dispatching its inner URLs to the KVM agent without re-validating them against the scheme allowlist; a related SSRF variant lets the Secondary Storage VM retrieve internal targets and persist them as downloadable templates. No public exploit identified at time of analysis, and no CVSS is provided by the vendor.

Missing authorization controls across multiple Userdata-related APIs in Apache CloudStack expose cross-tenant data to any authenticated CloudStack user. Affected APIs - deleteUserData, linkUserDataToTemplate, resetUserDataForVirtualMachine, deployVirtualMachine, updateVirtualMachine, and (from 4.21.0.0) deleteCniConfiguration - fail to validate that the requesting account owns the target userdata resource, enabling one tenant to read, delete, or manipulate another tenant's userdata. No public exploit or CISA KEV listing has been identified at time of analysis; EPSS of 0.13% at the 3rd percentile indicates low automated exploitation activity to date, though the multi-tenant cloud infrastructure context makes successful exploitation high-impact for affected operators.

Server-Side Request Forgery in Apache CloudStack's webhook module lets attackers coerce the management server into issuing arbitrary HTTP requests via webhook delivery, reaching internal-only services and cloud metadata endpoints that are otherwise unreachable from outside. It affects Apache CloudStack 4.20.0.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0, carries a CVSS 9.1 (high confidentiality and integrity impact), and has no public exploit identified at time of analysis. EPSS is low at 0.14% (4th percentile) and it is not on CISA KEV, indicating no observed active exploitation yet.

Sensitive OAuth configuration data is exposed to unauthenticated remote actors in Apache CloudStack's OAuth authentication plugin when the OAuth provider listing endpoint is queried. Affected versions span two release branches: 4.19.0.0-4.20.3.0 and 4.21.0.0-4.22.1.0. Despite a CVSS score of 7.5 reflecting unauthenticated network access and high confidentiality impact, EPSS sits at just 0.17% (7th percentile), and no public exploit code or CISA KEV listing has been identified at time of analysis, suggesting limited active exploitation to date.

Cleartext storage of sensitive information in Apache CloudStack's AsyncJob database records exposes credentials and operation-sensitive data to any party with read access to the underlying database. All CloudStack deployments from version 4.0.0 through 4.22.1.0 are affected across both the 4.x stable and 4.21/4.22 release lines. No public exploit code has been identified and EPSS sits at the 1st percentile, but the NVD-assigned confidentiality impact of HIGH reflects that AsyncJob records may capture sensitive payloads - such as API secrets or passwords - passed through asynchronous operations, stored durably in cleartext rather than encrypted at rest.

Unauthorized LDAP configuration disclosure in Apache CloudStack exposes LDAP server details - including bind credentials and hostnames - to any authenticated user via the listLdapConfigurations API, which is accessible to all default CloudStack roles. Affected versions span 4.2.0.0 through 4.22.1.0, a broad range suggesting long-standing exposure in enterprise and cloud provider deployments. No public exploit code has been identified at time of analysis, but the low barrier of a valid account and the downstream risk of harvested LDAP bind credentials elevate practical severity beyond the EPSS score suggests.

Two-factor authentication bypass in Apache CloudStack allows an authenticated low-privileged user to exploit an improper privilege management flaw in the 2FA plugin's disable flow, effectively circumventing the second authentication factor. Affected deployments span versions 4.18.0.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0, with vendor-confirmed fixes in 4.20.3.1 and 4.22.1.1. No public exploit code has been identified and EPSS sits at 0.18% (8th percentile), indicating low observed exploitation pressure despite the high vendor-assigned CVSS of 8.8.

Sensitive information exposure in Apache CloudStack's OAuth2 authentication plugin and Google OAuth integration allows unauthenticated remote attackers to access high-confidentiality data across two affected version ranges. The flaw is network-reachable with no authentication or user interaction required (CVSS AV:N/AC:L/PR:N/UI:N), making it a genuine High-severity finding for any CloudStack deployment with OAuth2 or Google OAuth enabled. EPSS sits at 0.17% (7th percentile) and no CISA KEV listing exists, suggesting no public exploitation activity at time of analysis; however, the low attack complexity and zero privilege requirement keep real-world risk elevated for affected configurations.

Improper output encoding in the Apache CloudStack management UI's Instance Reset Password feature allows injection of unescaped output that can expose sensitive data or manipulate the interface. It affects Apache CloudStack 4.15.1.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0, an open-source IaaS cloud orchestration platform. There is no public exploit identified at time of analysis, and EPSS exploitation probability is low (0.14%, 4th percentile); vendor-released patches exist in 4.20.3.1 and 4.22.1.1.

Improper output encoding in Apache CloudStack's management UI exposes administrators to cross-site scripting (XSS) when using the Lock User functionality across versions 4.20.0.0-4.20.3.0 and 4.21.0.0-4.22.1.0. A low-privilege user can embed a malicious script payload in a user-controlled field; when an administrator invokes the Lock User workflow, the CloudStack UI renders the payload without proper HTML or JavaScript escaping, executing it in the admin's browser session. No public exploit or CISA KEV listing has been identified at time of analysis, but the potential for admin session hijacking makes this a meaningful risk in multi-tenant environments.

Command injection in Apache CloudStack's diagnostics APIs allows Admin-role authenticated users to execute arbitrary commands as root on system VMs and Virtual Routers, constituting a full compromise of those instances across versions 4.20.0.0-4.20.3.0 and 4.21.0.0-4.22.1.0. The getDiagnosticsData and runDiagnostics API endpoints fail to properly neutralize special shell characters in user-supplied input before passing it to underlying diagnostic processes on the target VMs. No public exploit code or CISA KEV listing has been identified at time of analysis, but successful exploitation of a Virtual Router can expose all guest network traffic routed through that instance and provide a lateral movement foothold within the CloudStack-managed infrastructure.

Pre-validation SSRF in Apache CloudStack's template and ISO registration allows authenticated users to trigger HTTP HEAD/GET requests to arbitrary URLs - including internal network resources - before URL validation is applied. Affected versions are 4.20.3.0 and 4.21.0.0 through 4.22.1.0; vendor-released patches exist in 4.20.3.1 and 4.22.1.1. No public exploit code or active exploitation has been identified at time of analysis, and exploitation requires valid CloudStack credentials with template-registration privileges.

Cross-tenant manipulation in Apache CloudStack's Kubernetes Service (CKS) plugin allows a tenant to add and remove nodes on Kubernetes clusters belonging to other tenants, affecting versions 4.21.0.0 through 4.22.1.0. The improper access control breaks tenant isolation in a multi-tenant IaaS platform, enabling unauthorized integrity and confidentiality impact against neighboring tenants' clusters. No public exploit identified at time of analysis, and EPSS is low (0.13%, 3rd percentile) despite the 9.1 CVSS.

Sensitive information exposure in Apache CloudStack's Webhook module allows unauthorized actors to view data they should not have access to during webhook delivery listing and deletion operations. Affected deployments span versions 4.20.0.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0, covering two active release trains. No public exploit or active exploitation has been identified at time of analysis; vendor-released patches are available.

Missing authorization in Apache CloudStack's listHostTags API allows domain administrators to enumerate host tags across all domains in a multi-tenant deployment, violating tenant isolation boundaries established by the domain hierarchy. Affected versions span 4.12.0.0 through 4.22.1.0 across two release trains, with vendor-released patches in 4.20.3.1 and 4.22.1.1 confirmed by the Apache security advisory. No public exploit code exists and the vulnerability is not listed in CISA KEV, but the risk is meaningful in shared, multi-tenant CloudStack environments where cross-domain host tag visibility undermines infrastructure confidentiality guarantees between tenants.

Broken object-level authorization in Apache CloudStack exposes project role management APIs to Domain Admins operating outside their assigned domain scope. Authenticated Domain Admins can create, update, delete, and enumerate project roles and role permissions for projects belonging to entirely unrelated domains, because the authorization check validates only that the caller holds the Domain Admin role without confirming the target project falls within their domain or any subdomain hierarchy. Affected versions span 4.15.0.0 through 4.20.3.0 and 4.21.0.0 through 4.22.1.0; no public exploit has been identified at time of analysis and EPSS probability is very low at 0.13%.

Improper access control in Apache CloudStack's annotation APIs (addAnnotation and listAnnotation) allows any authenticated user to read and write annotations on entities they do not own. The APIs perform an ownership check when an entity UUID is supplied but fail to enforce the result of that check, reducing authorization to a formality that any authenticated user can bypass. No public exploit has been identified at time of analysis; no EPSS or CISA KEV data is available, but the bug affects all CloudStack deployments from 4.15.0.0 onward until the patched releases.

SAML authentication bypass in Apache CloudStack 4.20.3.0 and 4.22.1.0 permits a network-positioned attacker to forge SAML responses and authenticate as any user against the management server without valid credentials. The flaw stems from improper cryptographic signature verification (CWE-347): the management server fails to validate SAML response certificates, so a forged assertion passes unchecked. Exploitation requires either spoofing the IdP's IP address or registering a controlled URL as a trusted IdP endpoint in the management server - conditions that raise the practical bar but, if met, yield full administrative access. No public exploit or CISA KEV listing has been identified; the EPSS score of 0.07% reflects minimal observed exploitation at time of analysis.

Remote code execution in Microsoft's Azure Managed Instance for Apache Cassandra allows an unauthenticated network attacker to inject additional command-line arguments (CWE-88) into a backend process and execute arbitrary code, per the CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C) that indicates no authentication or user interaction and a scope change beyond the vulnerable component. Microsoft reported the issue and has released a fix through MSRC. No public exploit is identified at time of analysis, and the CVE is not currently listed in CISA KEV.

OS command injection in Laravel Backpack CRUD's Stats::makeCurlRequest method allows unauthenticated remote attackers to execute arbitrary OS commands as the web server user by supplying a crafted HTTP Host header. All four maintained branches are affected: 4.1.x before 4.1.72, 5.x before 5.6.2, 6.x before 6.8.13, and 7.x before 7.0.36. No public exploit code or CISA KEV listing exists at time of analysis, but the only in-code guard is a 1-in-100 probabilistic gate that provides no meaningful protection against a determined attacker who can retry requests.

SQL injection in Apache InLong versions 2.0.0 through 2.3.x (fixed in 2.4.0) lets attackers inject malicious SQL through the ORDER BY clause of a Manager backend query, enabling extraction or manipulation of data in the Manager database. The flaw is unparameterizable at its root because ORDER BY clauses cannot use bind variables, so improper neutralization directly exposes the query. It carries a CVSS 9.8 rating with a network vector, but real-world urgency is tempered by a low EPSS score (0.21%, 11th percentile) and no evidence of exploitation - no public exploit identified at time of analysis and it is not on the CISA KEV list.

Server-Side Request Forgery in Apache InLong Manager (versions 2.0.0-2.3.x) allows any authenticated user - no administrative role required - to coerce the Manager service into issuing outbound HTTP requests or TCP connections to arbitrary internal hosts and ports. This effectively turns the InLong Manager into an open proxy for internal network reconnaissance, enabling access to otherwise firewalled services such as cloud instance metadata endpoints, internal APIs, or database management interfaces. No public exploit has been identified at time of analysis, but the low privilege bar makes this broadly reachable within any deployment that permits shared user access.

Arbitrary file read in Apache InLong 2.0.0 through 2.3.x exposes the Agent host filesystem to unauthenticated remote attackers via a relative path traversal flaw. The CVSS vector AV:N/AC:L/PR:N/UI:N confirms exploitation requires no credentials or user interaction, making any network-exposed InLong Agent endpoint a direct confidentiality risk. No public exploit code and no CISA KEV listing have been identified at time of analysis; EPSS sits at 0.21% (12th percentile), indicating low observed exploitation probability despite the high base score.

Broken access control in Apache InLong's manager component exposes Data Node management endpoints to any authenticated user, regardless of their assigned role or privilege level. Versions 2.0.0 through 2.3.x are affected, allowing any valid manager account holder to create, modify, or delete Data Node definitions that underpin the platform's data pipeline infrastructure. The CVSS 8.1 High rating reflects high integrity and availability impact; no public exploit or CISA KEV listing exists at time of analysis.

Missing authorization enforcement in Apache InLong's StreamSource component allows any authenticated user - regardless of role - to logically delete all stream sources across the platform. Versions 2.0.0 through 2.3.x are affected; the root cause is CWE-552, where the StreamSource API performs no access-control check before executing the delete operation. No public exploit code is currently known and the vulnerability is absent from CISA KEV, but the extremely low exploitation barrier - a single valid account - makes this a serious risk for any multi-tenant or shared InLong deployment.

SQL injection in Apache InLong versions 2.0.0 up to (but not including) 2.4.0 allows attackers to inject attacker-controlled string values into a SQL statement, giving full read/write access to the backing database. The flaw carries a critical CVSS 3.1 score of 9.8 (network, no authentication, no user interaction) and is fixed in 2.4.0. No public exploit identified at time of analysis, and the EPSS probability is low (0.19%, 9th percentile), so despite the critical score there is no evidence of active exploitation yet.

SQL injection in Apache InLong versions 2.0.0 through 2.3.x allows remote attackers to inject arbitrary SQL via the dbName, tableName, schemaName, and username parameters, compromising the integrity and confidentiality of the backend database. The flaw carries a CVSS 9.8 (network, no authentication, no user interaction) and was disclosed by the Apache project itself; a vendor patch exists in 2.4.0. There is no public exploit identified at time of analysis, and EPSS estimates exploitation probability at a low 0.21% (11th percentile).

Uncontrolled Resource Consumption (CWE-400) in Apache InLong versions 2.0.0 through 2.3.x exposes two related attack surfaces: authenticated users can trigger excessive resource consumption to degrade service availability, and the same pathway permits upload of non-official packages, introducing a package-integrity risk alongside the denial-of-service vector. Affected deployments running any release in the 2.0.0-2.3.x range should treat this as a priority upgrade given the dual nature of the flaw. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

Unauthorized template information disclosure in Apache InLong 2.0.0 through 2.3.x allows authenticated users who are not designated template responsible persons to view template configurations they should not have access to. The CVE is tagged CWE-400 (Uncontrolled Resource Consumption) and classified as Denial of Service, yet the description describes an access control bypass - this is a data contradiction that analysts should flag before making control decisions. No public exploit or active exploitation has been identified. Vendor fix is available in Apache InLong 2.4.0.

JWT bearer token leakage in the Grav API Plugin for Grav CMS (prior to 1.0.0-rc.16) exposes valid access tokens to any party with access to server logs, proxy logs, CDN logs, browser history, or Referer headers. The JwtAuthenticator::extractBearerToken() method accepted tokens supplied via the ?token= URL query parameter on every /api/v1 route - including state-changing endpoints - rather than restricting token-in-URL to the file-download routes where it is technically necessary. An attacker who obtains a token from those secondary log sources can replay it with the full API privileges of the original token owner. No active exploitation (CISA KEV) or public exploit code has been identified at time of analysis.

Case-sensitivity bypass in Grav's Apache .htaccess rules prior to version 2.0.4 allows unauthenticated remote attackers to retrieve password hashes and security configuration files by requesting uppercase or mixed-case path variants (e.g., `/USER/accounts/admin.yaml`) on case-insensitive filesystems. The protection boundary - Apache mod_rewrite RewriteRule directives blocking access to user/accounts, user/config, user/data, and user/env - fails entirely when the underlying filesystem resolves uppercase URLs to the same protected files that lowercase rules would block. No public exploit or CISA KEV listing has been identified at time of analysis, but the attack requires no authentication and no user interaction, making it trivially repeatable against eligible deployments.

Arbitrary file write in the W3 Total Cache WordPress plugin before 2.10.5 lets unauthenticated remote attackers overwrite any existing file inside or outside the web root by manipulating the request path used to construct cache file names. Because the plugin builds cache filenames from an unvalidated path, attackers can clobber security-critical files such as Apache .htaccess, breaking the site and stripping hardening rules that other controls depend on. No public exploit identified at time of analysis and EPSS is low (0.18%), but SSVC rates technical impact as total and the flaw is automatable, so priority is high despite the current lack of observed exploitation.

Customer-uploaded file disclosure in Extra Product Options Builder for WooCommerce (all versions before 1.2.176) allows unauthenticated requesters who know a file's stored name to retrieve it via an unprotected plugin endpoint, bypassing a missing authorization check (CWE-862). The real-world severity is conditional on web server type: the plugin writes deny-all rules to upload directories, meaning this endpoint only crosses a new security boundary on Apache-hosted sites; on default nginx deployments, those files are already directly URL-accessible and the endpoint adds no measurable additional exposure. Publicly available exploit code exists, but no public exploit identified at time of analysis confirms active exploitation, and EPSS sits at 0.22% (12th percentile) despite the elevated CVSS score.

Unbounded locale cache growth in Apache Struts allows unauthenticated remote attackers to exhaust JVM heap memory and deny service to all users of the application. The vulnerability spans an exceptionally wide version range - from 2.0.0 through 7.2.1 across four release branches - and is exploitable only when no fixed locale is configured, a condition common in multilingual deployments. No public exploit has been identified at time of analysis, and EPSS at 0.19% (9th percentile) reflects low observed exploitation activity; however, the network vector with zero prerequisites on vulnerable configurations makes this a meaningful DoS risk in exposed environments.

Unbounded memory consumption in Apache Struts allows a single unauthenticated HTTP request to exhaust JVM heap and deny service to all concurrent users on applications that expose a Content Security Policy violation report collection endpoint. Affected versions span the 6.0.0-6.10.0 and 7.0.0-7.2.1 release branches; applications that have not implemented a custom CSP report endpoint are unaffected regardless of Struts version. No public exploit code has been identified and EPSS places current exploitation probability at 0.23% (14th percentile), though the trivial, unauthenticated attack path means any exposed endpoint represents a reliable, low-effort denial-of-service target.

Cross-request data leakage in Apache Struts 7.2.1's JSON plugin allows an authenticated remote attacker to observe response content associated with a concurrent request belonging to a different user. The root cause is a thread-safety defect (CWE-567) in the SMD/JSON-RPC interceptor, where per-response serialization state is not isolated between concurrent requests. Exploitation is constrained to the non-default SMD/JSON-RPC mode of the JSON interceptor; no public exploit code has been identified at time of analysis, and the EPSS score of 0.15% (4th percentile) reflects the limited realistic exploitation surface.

Cross-request data exposure in the Apache Struts JSON plugin (version 7.2.1) results from per-request parsing state being improperly shared across concurrent requests, enabling information observable in one user's session to leak into another's. Authenticated remote attackers targeting applications that have explicitly enabled JSON action population can exploit this concurrency flaw (CWE-567) to read partial request data or circumvent configured parsing limits. With an EPSS of 0.15% (4th percentile), no CISA KEV listing, and no public exploit identified at time of analysis, real-world risk is low and narrowed further by the non-default plugin requirement.

Heap exhaustion via unbounded JSON body reading in the Apache Struts JSON plugin allows unauthenticated remote attackers to deny service by sending a single oversized HTTP request to any endpoint where request-body-to-action population is enabled. Affected version ranges span the 2.x, 6.x, and 7.x release lines. No public exploit code has been identified at time of analysis and SSVC signals no active exploitation, but the attack is rated automatable, meaning scripted large-scale scanning and denial-of-service campaigns are feasible against exposed endpoints.

Remote code execution in Velocity.js (npm 'velocityjs') versions <= 2.1.6 lets an attacker who controls template content reach the JavaScript Function constructor and run arbitrary code in the server process. The earlier CVE-2026-44966/GHSA-j658-c2gf-x6pq fix only filtered constructor/__proto__/prototype in the #set assignment target, leaving property-read expressions in references.ts unguarded, so this is a straightforward bypass. Publicly available exploit code exists (a working PoC is published in the GHSA advisory and was vendor-verified on v2.1.6); no confirmed active exploitation (not in CISA KEV).

Remote code execution via the OpenSearch SQL plugin's Flint extension query handler exposes Apache Spark workers to arbitrary code execution by any authenticated user holding async query access. The vulnerable component is the SQL query validation layer in the Flint extension, which fails to prevent crafted payloads from reaching and executing on Spark worker nodes. No public exploit code has been identified at time of analysis, but the network-reachable RCE primitive, low complexity, and low privilege requirement collectively make this a high-priority remediation target; vendor patches are available in OpenSearch 3.7.0 and 2.19.6.

Remote code execution in Apache Shindig (all versions) is reachable via the project's REST API, where deserialization of attacker-controlled input allows server-side arbitrary code execution. The vulnerability requires high-privilege API access (CVSS PR:H), limiting opportunistic exploitation, but every deployed instance is permanently exposed because the Apache Software Foundation has retired the project and will not release a fix. No public exploit or KEV listing has been identified at time of analysis, but the combination of RCE impact and no-patch status makes any continued deployment a long-term liability.

Cross-site scripting in Apache Allura's Markdown rendering (versions 1.10.0 up to but not including 1.19.1) allows an attacker to inject script-related HTML into content that other users view, executing arbitrary JavaScript in their browsers. Because Allura is a collaborative forge where users routinely post Markdown in tickets, wiki pages, and comments, the payload is most likely stored and delivered to victims who open the affected page. No public exploit identified at time of analysis, and there is no CISA KEV listing or POC signal; the Apache PMC has released version 1.19.1 as the fix.

Cross-site scripting (XSS) in Apache Allura's code-display feature allows an attacker who can place crafted content into a rendered code view to execute arbitrary JavaScript in the browser of any user who views that code, in all versions before 1.19.1. Because Allura is forge/project-hosting software, a successful attack can hijack the sessions of project members or administrators. There is no public exploit identified at time of analysis, and the issue is not listed in CISA KEV.

Insecure Direct Object Reference (IDOR) in Apache Allura before 1.19.1 allows unauthorized access to multiple Artifact types due to missing server-side permission checks. Attackers who can interact with the platform can reference artifact objects directly by their identifiers and retrieve content beyond their authorization level, resulting in information disclosure across potentially broad artifact categories. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Remote code and command injection in Apache Allura before 1.19.1 lets unauthenticated attackers smuggle attacker-controlled arguments into git command invocations through specially crafted inputs. Because Allura is a project-hosting and forge platform that shells out to git, this argument injection (CWE-88) can be leveraged to influence git behavior and, depending on the invoked subcommand, achieve command execution against the hosting server; no public exploit has been identified at time of analysis and EPSS exploitation probability is low (0.18%).

Secret exposure in Apache Airflow's Rendered Templates UI allows any authenticated user with task-level view access to read plaintext credential values that should have been masked. The secrets masker's `isinstance(str)` guard silently skips dict-typed Python objects, meaning JSON Variables accessed via `var.json` and containing dict payloads (e.g., database credentials, API keys stored as structured JSON) are rendered in cleartext rather than redacted. No public exploit is identified at time of analysis; however, the disclosure requires nothing more than standard UI navigation by a legitimately authenticated user.

Unsafe deserialization in Apache Airflow 3.0.0 through 3.3.0 allows any DAG author to achieve arbitrary code execution in the Scheduler and API server by placing a crafted value in an operator's executor_config field. The serialization layer reconstructed exception nodes by calling import_string() on an attacker-controlled class name with no allowlist, enabling import and invocation of arbitrary callables such as subprocess.check_output or builtins.eval. Both affected components hold the metadata database credentials and JWT signing secret, making full infrastructure compromise a realistic outcome. No public exploit has been identified at time of analysis, but no non-default configuration is required. This is a distinct sink from CVE-2026-33264, meaning deployments that already patched that earlier advisory remain fully vulnerable and must upgrade again to apache-airflow 3.3.1.

Unsafe deserialization in Apache Airflow's XCom REST API allows an authenticated user with XCom write-and-read access to instantiate arbitrary `airflow.*` classes on the API server by smuggling reserved serialization keys inside JSON string literals. The `_check_forbidden_xcom_keys` guard inspected `dict`, `list`, and `tuple` types but did not attempt to JSON-decode `str` values, so a payload like `json.dumps({"__classname__": "airflow.sdk.definitions.connection.Connection"})` passed the write-time check and was later reconstructed into a live Python object when read back via `?deserialize=true`. No public exploit has been identified at time of analysis; vendor-released patch is available in apache-airflow 3.3.1.

Sensitive values stored as deeply nested lists, tuples, or sets in Apache Airflow Variables are displayed unmasked in the Variables UI due to a recursion-depth logic error in the secrets masker. This is an incomplete-fix follow-up to CVE-2026-42358: that prior fix made dictionary traversal unbounded but left list/tuple/set structures subject to the depth cutoff, allowing values beyond that depth to appear in plaintext on screen. The practical impact is narrow - any authenticated user who can see the Variable in the UI already has read access to the full value through the Variables REST API - making this a shoulder-surfing defense gap rather than an access-control bypass. No public exploit has been identified at time of analysis.

Remote code execution and scheduler-process disruption in Apache Airflow 3.3.0 stems from unguarded deserialization of task instance `next_kwargs` during the scheduler's unconditional `awaiting_input` sweep, a code path introduced as part of the 3.3.0 human-in-the-loop task rewrite. Any authenticated DAG author who can influence task state through the task execution API can supply a crafted payload that causes arbitrary module import and object instantiation inside the scheduler process, or terminate the scheduler job entirely. No public exploit has been identified at time of analysis, but a vendor-released patch exists in 3.3.1; deployments that previously patched CVE-2026-58076 are still vulnerable through this distinct code path and must upgrade.

Unsafe deserialization in Apache Airflow 3.3.0's Task SDK allows an authenticated DAG author to cause arbitrary module imports inside the scheduler process. By controlling a task instance's `next_kwargs` via the task execution API, an attacker can inject a crafted callback path that the scheduler's unconditional `awaiting_input` timeout sweep deserializes by re-running the `SyncCallback` constructor - triggering an import of the named module in the scheduler's process space. Because `SyncCallback` is itself an Airflow class, it bypasses the `allowed_deserialization_classes` allow-list, making tightening that setting ineffective. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS score of 8.8 reflects the severity of the potential scheduler process compromise.

Sensitive credential exposure in Apache Airflow 3.3.0 allows an authenticated Viewer with configuration-read access to retrieve team-scoped sensitive options - including Celery broker URLs with embedded credentials - in cleartext via the Config API. The secrets masker evaluated sensitivity against raw section names without resolving team-prefixed sections (e.g., [team_a=celery]) back to their registered base section, so team-scoped overrides silently bypassed masking while equivalent global options were correctly redacted. This is a third distinct masker bypass variant following CVE-2026-48828 and CVE-2026-48892, meaning deployments that already upgraded to 3.3.0 to remediate those issues remain exposed. No public exploit identified at time of analysis.

Authorization bypass in Apache Airflow's Backfill API (all versions prior to 3.3.1) allows any authenticated user holding edit permission on a single DAG to read, pause, cancel, and fail backfills belonging to any other DAG. The flaw is a type-parsing mismatch in FastAPI's dependency resolution layer: the authorization dependency parsed the `backfill_id` path parameter with Python's `int()` while the route handler declared `NonNegativeInt` via Pydantic, which in lax mode coerces inputs like `'42.0'` that `int()` rejects-causing the two components to authorize and act on different DAGs. Backfill IDs are sequential, making cross-DAG enumeration trivial; no public exploit code has been identified at time of analysis, though the technique is directly reproducible from the published patch diff.

Cleartext secret exposure in Apache Airflow's audit log affects all versions before 3.3.1, allowing any authenticated user with audit-log read access to recover Variable values and Connection `extra` credentials verbatim - without holding Variables or Connections read permissions. The bulk API endpoints (`PATCH /api/v2/variables`, `PATCH /api/v2/connections`) bypassed audit-log masking because the masker inspected only top-level request fields while bulk payloads nest entities two levels deep under `actions[].entities[]`. The Airflow UI's Import Variables action posts to this same bulk endpoint, meaning a routine operator import silently writes every secret in the uploaded file to the unmasked audit log. No public exploit is identified at time of analysis, but the vulnerability is fully exploitable by any authenticated user with log access, and deployments that upgraded to 3.3.0 in response to the related CVE-2026-50204 remain vulnerable and must upgrade again.