CVE Catalog

A vulnerability in Apache Airflow's authentication managers, FabAuthManager and KeycloakAuthManager, allowed previously-issued JSON Web Tokens (JWT) to remain valid after a user logged out. The logout process did not properly invoke the token revocation function, leaving the JWT accepted by the API server until it naturally expired. This issue could be exploited by an attacker with access to a JWT of a logged-out user, enabling them to make authenticated API calls as that user. The vulnerability affects Apache Airflow versions prior to 3.2.2.

A vulnerability exists in the Apache Airflow Event Log detail endpoint `GET /api/v2/eventLogs/{event_log_id}` prior to version 3.2.2. This endpoint retrieves audit-log rows by numeric ID, after only a basic Audit Log permission check. In contrast, the collection endpoint `GET /api/v2/eventLogs` enforces per-DAG permission scoping. As a result, an authenticated user with audit-log read permission for one DAG could access audit-log entries for other DAGs by guessing or enumerating event log IDs. This issue affects deployments that depend on per-DAG audit-log scoping.

A vulnerability exists in Apache ActiveMQ in versions prior to 5.19.7 and in the 6.0.0 series prior to 6.2.6. This vulnerability stems from incomplete authorization, which allows authenticated connections with the appropriate permissions to remove existing destinations. The issue is present in Apache ActiveMQ Broker, Apache ActiveMQ All, and Apache ActiveMQ, all within the specified version ranges.

A code injection vulnerability has been identified in Apache ActiveMQ Broker, ActiveMQ All, and ActiveMQ. This issue arises from improper input validation in non-parenthesized discovery wrappers, which allows authenticated attackers to bypass security measures and execute arbitrary code on the broker's JVM. The vulnerability is exploited through the Jolokia JMX-HTTP bridge, where the default access policy permits execution operations on ActiveMQ MBeans. By crafting a specific discovery URI, an attacker can manipulate the VM transport's brokerConfig parameter to load a remote Spring XML application context. This exploitation takes place before the BrokerService validates the configuration, leading to unauthorized code execution via bean factory methods such as Runtime.exec().

A vulnerability exists in Apache Airflow's log server JWT authorization process, specifically in versions 3.0.0 prior to 3.2.2. The issue arises because the log server applies Python's 'str.lstrip()' method to the requested path segment when verifying the JWT's 'sub' claim. This method strips characters from the left side of the string, allowing a JWT issued for a DAG named 'dag_a' to authorize log access to any other DAG whose name started with any combination of the characters '{d, a, g, _}'. As a result, an authenticated Airflow worker could potentially access and read logs from other DAGs that shared a similar name prefix, thereby leaking task outputs and error traces across DAG boundaries. This vulnerability affects deployments with multi-team, shared-executor, and shared-worker topologies that rely on per-DAG log access scoping.

A vulnerability exists in Apache Airflow's scheduler-side deadline-reference decoder, specifically in versions prior to 3.2.2. The issue arises because the decoder imports and dispatches arbitrary class paths from DAG-author-controlled serialized state without any allowlist or plugin-registry validation. In environments where DAG-author code is less trusted than the scheduler process, a DAG author could embed a custom 'DeadlineReference' that references an attacker-controlled module path. This would lead the scheduler to import the specified class and instantiate it with an active SQLAlchemy session. The vulnerability is particularly concerning in single-host deployments where the DAG bundle can be imported by the scheduler.

A vulnerability exists in Apache Solr versions 9.4.0 through 9.10.1 and 10.0.0, where hardcoded credentials in the Basic Authentication setup tool enable remote attackers to gain full administrative access to the cluster. This is achieved through publicly known default credentials that are silently installed alongside the user-specified account. The vulnerability arises when the 'bin/solr auth enable' command is used to bootstrap Basic Authentication, creating template users with default passwords that can be exploited. Clusters that have not used this command or have assigned strong passwords to the template users after bootstrapping are not affected.

A code injection vulnerability allowing remote code execution has been identified in Apache ActiveMQ Broker, ActiveMQ All, and ActiveMQ Classic. This issue arises from improper input validation and control over code generation. The Jolokia JMX-HTTP bridge is exposed by default on the web console, and the access policy allows execution operations on all ActiveMQ MBeans. An authenticated attacker can exploit this by sending a crafted discovery URI that triggers the VM transport's brokerConfig parameter, using the 'masterslave://' URL to load a Spring XML application context. This exploitation occurs because Spring's ResourceXmlApplicationContext instantiates singleton beans before the BrokerService can validate the configuration, leading to arbitrary code execution on the broker's JVM through methods like Runtime.exec().

A vulnerability in Apache Airflow prior to version 3.2.2 allows for the bypass of nested sensitive-key masking in rendered-template fields. When a rendered field exceeded the maximum templated field length, Airflow converted the structure to a string before redaction, losing the context of nested keys such as 'password', 'token', 'secret', or 'api_key'. This resulted in plaintext values being saved into 'rendered_fields', potentially exposing sensitive information. The issue affects deployments where DAG authors use structured JSON with nested sensitive keys. This vulnerability is related to CWE-200 and is a continuation of an earlier issue addressed in CVE-2025-68438, which did not fully cover nested sensitive keywords.

A vulnerability in Apache Airflow's XCom PATCH endpoint allowed authenticated users with XCom write permission to overwrite entries under reserved key names, such as 'return_value'. This exploitation was possible because the PATCH endpoint did not enforce the same key validation as the POST endpoint, creating a bypass. Additionally, the endpoint accepted serialized payloads that could be interpreted as code, leading to remote code execution when the affected task was deferred. This issue impacts deployments where untrusted users can write to XCom on Dags that defer to them.

A vulnerability in Apache Airflow's Variable response masker allows for the bypass of nested-key redaction for sensitive key names such as 'password', 'token', 'secret', and 'api_key'. This issue arises when the JSON value's nesting depth exceeds the masker's recursion limit, causing the masker to return the original nested item before verifying the key name. As a result, an authenticated user with Variable read permission could access plaintext secret values stored under sensitive keys that are deeply nested. This vulnerability affects deployments with sensitive data in complex JSON Variables and represents a gap in the previous fix for CVE-2026-32690, which only addressed shallower nesting. Users who upgraded for CVE-2026-32690 should now upgrade to Apache Airflow 3.2.2 or later to address this issue.

A cross-site scripting vulnerability has been identified in Apache ActiveMQ and Apache ActiveMQ Web. The issue arises in the MessageServlet of the ActiveMQ web console API, which improperly neutralizes input during web page generation. Specifically, the servlet copies all JMS message properties into HTTP response headers without validation. This flaw can be exploited to overwrite and inject security headers by manipulating JMS messages returned by the servlet. The vulnerability affects Apache ActiveMQ versions prior to 5.19.7 and 6.0.0 versions prior to 6.2.6, as well as Apache ActiveMQ Web versions prior to 5.19.7 and 6.0.0 versions prior to 6.2.6.

A shell metacharacter injection vulnerability has been identified in Apache Airflow versions 3.0.0 prior to 3.2.2. The issue arises from the official documentation example for the BashOperator, which demonstrated how to pass parameters using Jinja templating without any warning about quoting or sanitization. This oversight could lead to exploitation in deployments where users have the 'Dag.can_trigger' permission, such as typical multi-team environments or hosted offerings that expose a trigger API. An authenticated user could inject malicious commands through the 'conf' field of the trigger API, potentially executing arbitrary commands on the worker via 'os.exec'.

An authorization bypass vulnerability has been identified in Apache Airflow's bulk Task Instances API, specifically in versions 3.2.0 prior to 3.2.2. The issue arises because the API evaluated authorization based on the DAG ID in the URL path, while the actual operation was performed using DAG IDs extracted from the request body. This flaw allowed an authenticated user with edit permissions on one DAG to modify the Task Instance state of any other DAG by manipulating the request body. The vulnerability impacts deployments that use per-DAG edit scopes to maintain Task Instance state separation between teams.

A vulnerability exists in Apache Airflow's JWTRefreshMiddleware, where the JWT authentication cookie is set without the Secure flag. This issue affects deployments running the Airflow API server behind an HTTPS-terminating reverse proxy, such as nginx, Envoy, or a managed load balancer that terminates TLS and forwards plaintext to the API server. In these scenarios, the absence of the Secure flag allows a network-positioned attacker to capture and replay the JWT cookie over unencrypted HTTP requests to the same host, compromising session integrity.

A vulnerability exists in the Apache Airflow UI in versions 3.2.0 prior to 3.2.2, specifically within the partitioned_dag_runs endpoints. This issue arises because the endpoints only enforce asset-level access control, lacking per-DAG authorization. As a result, an authenticated user with global Asset:read permission could access and enumerate partition run states, schedule configurations, and asset wiring for DAGs that they were not authorized to read. This vulnerability impacts deployments that depend on per-DAG read permissions while allowing users broader Asset access.

A vulnerability exists in the Apache Airflow UI structure_data endpoint, where it improperly handles authorization for external dependency graph nodes linked to other Directed Acyclic Graphs (DAGs). This flaw allows an authenticated user with access to one DAG to enumerate linked DAG IDs and dependency metadata from other DAGs they do not have permission to read. The issue affects Airflow versions 3.0.0 prior to 3.2.2 and impacts deployments that use per-DAG read permissions to maintain DAG dependency privacy across teams.

A vulnerability in the login redirect route of Apache Airflow versions 3.0.0 prior to 3.2.2 allows authenticated users to create URLs that bypass the 'is_safe_url' check. This flaw enables redirection from a trusted Airflow domain to an attacker-controlled destination. As a defense-in-depth measure, deployment operators can place Airflow behind a reverse proxy that removes off-domain 'next=' query parameters before they reach the login endpoint.

A vulnerability exists in Apache Airflow versions prior to 3.2.2, allowing a DAG author to create a symlink in their task's log directory that points to an arbitrary file readable by the API server process. This read-path attack could target files like '/etc/passwd' or 'airflow.cfg'. Alternatively, the author could supply a 'task_id' with '..' sequences that bypass the Task SDK's 'KEY_REGEX', leading to a write-path attack. In both scenarios, the FileTaskHandler resolves the log path outside the designated 'base_log_folder', causing unauthorized leakage or overwriting of files. This issue arises only in deployments where the worker log folder is shared with the API server.

A Cross-Site Request Forgery (CSRF) vulnerability has been identified in SOPlanning version 1.55 and below. This vulnerability exists in the 'groupe_save' create, modify, and delete endpoints. An attacker can create a malicious website that, when visited by an authenticated user, automatically sends a forged GET or POST request to the application.

A vulnerability exists in SOPlanning versions through 1.55, allowing authenticated attackers with access to the backup functionality to upload ZIP archives containing malicious files. The application does not properly validate file extensions, enabling the inclusion of harmful files alongside legitimate ones, such as a user.csv file. Once uploaded, the malicious file can be extracted on the server. This vulnerability, when combined with a separate path traversal issue (CVE-2026-40547), could lead to the execution of the malicious file, such as a PHP script, from a web-accessible location.

A path traversal vulnerability has been identified in SOPlanning backup endpoints, allowing authenticated remote attackers to read and execute files uploaded through the backup feature. This issue is exacerbated by a missing authorization vulnerability, CVE-2026-40543, which enables any unauthorized user to access backup files. The vulnerability affects SOPlanning versions through 1.55.

A SQL injection vulnerability has been identified in SOPlanning, an online project management tool, affecting all versions through 1.55. This vulnerability allows attackers with low privileges to inject arbitrary SQL commands, potentially leading to full control over the application's database. The issue arises from improper input validation across multiple endpoints and parameters, leaving the application susceptible to SQL injection attacks.

A reflected cross-site scripting vulnerability has been identified in SOPlanning versions through 1.55. The issue arises in the 'taches' parameter, where an attacker can create a malicious URL that, when accessed by an authenticated user, executes arbitrary JavaScript in the user's browser.

A stored cross-site scripting vulnerability has been identified in SOPlanning versions through 1.55. The issue arises in the '/process/upload_backup' endpoint, where an authenticated attacker can upload a ZIP archive containing a malicious 'user.csv' file with embedded JavaScript. This injected code is executed in the browser of any user who clicks the 'Edit' button for the affected backup.

A vulnerability exists in SOPlanning versions through 1.55, where the application fails to enforce proper authorization for backup functionalities. This allows unauthenticated attackers to directly access backup-related endpoints and retrieve archives containing user databases with usernames and password hashes, as well as a config.csv file with additional sensitive information. The issue arises from the lack of authorization checks, enabling unauthorized access to critical data through the backup functionality.

A privilege chaining vulnerability has been identified in ServerView Agents for Windows, all versions through 11.60.04. This vulnerability allows a local authenticated attacker to escalate privileges and obtain SYSTEM rights on the affected server.

A vulnerability exists in ServerView Agents for Windows versions through 11.60.04, involving incorrect permission assignments that could allow a local authenticated user to execute code with SYSTEM privileges. This issue arises from improper file access rights that could be exploited by general users.

A server-side request forgery (SSRF) vulnerability has been identified in Clair's fetcher component. This issue arises because the fetcher makes outbound HTTP requests to attacker-supplied URIs from manifest layer descriptors without filtering IP addresses or schemes. When pre-shared key (PSK) authentication is not enabled—an opt-in feature not enforced by default—an unauthenticated attacker can submit a manifest with a URI that points to internal services or cloud metadata endpoints. The SSRF is reflective for non-200 responses, leaking up to 256 bytes of error body content through CheckResponse error messages. While operator-managed Red Hat Quay deployments automatically configure PSK and are not vulnerable to this unauthenticated attack vector, standalone Clair deployments without PSK configuration are exposed.

A vulnerability allowing unauthenticated access to critical admin functions has been identified in Code-Projects Smart Parking System version 1.0. The issue arises from multiple admin endpoints that lack proper authentication, enabling remote attackers to perform privileged actions without any session or credentials. Exploitation of this vulnerability could lead to unauthorized creation of attendant accounts, manipulation of parking records, and exposure of personal customer information.

A SQL injection vulnerability has been identified in the itsourcecode Content Management System version 1.0. The issue resides in the '/instructions.php' file, where the 'topic_id' parameter is not properly sanitized, allowing attackers to inject malicious SQL queries. This vulnerability can be exploited remotely, potentially leading to unauthorized database access, data manipulation, and disruption of service.

A server-side request forgery (SSRF) vulnerability has been identified in JeecgBoot versions prior to 3.9.2. The issue arises in the '/airag/app/debug' endpoint, where the server processes URLs through the 'FileDownloadUtils.download2DiskFromNet' function. This vulnerability allows authenticated attackers to send arbitrary internal or external URLs, which the server then fetches without proper validation. As a result, the application can be manipulated to make outbound HTTP requests to internal services, local ports, or cloud instance metadata endpoints, such as 169.254.169.254.

A server-side request forgery (SSRF) vulnerability exists in JeecgBoot versions through 3.9.2. The issue is located in the AiragModel test endpoint, where the application improperly validates the baseUrl parameter. This flaw allows authenticated attackers to send requests to internal resources or cloud metadata endpoints, potentially accessing sensitive information or probing internal services. The vulnerability is exacerbated by the absence of permission checks on the endpoint, allowing any authenticated user to exploit it. Additionally, the malicious baseUrl is persisted in the database, creating a stored SSRF condition.

A stored server-side request forgery (SSRF) vulnerability has been identified in JeecgBoot versions through 3.9.2. The issue arises in the Word template processing feature, specifically within the 'WordUtil.addImage' function. This vulnerability allows an attacker to inject malicious HTTP URLs into the database via the 'main' field of a Word template, using the '/airag/word/edit' endpoint. When the template is later downloaded through the '/airag/word/download' endpoint, the server fetches the image from the injected URL, lacking proper validation. This flaw can be exploited to scan internal networks or access sensitive cloud metadata.

A SQL injection vulnerability has been identified in the User Management Module of SourceCodester Water Billing Management System version 1.0. The issue arises in an unknown function of the file '/admin/?page=user/manage_user', where manipulation of the 'ID' argument allows for SQL injection. This vulnerability can be exploited remotely, and the exploit has been made public.

An improper authorization vulnerability has been identified in SourceCodester Water Billing Management System version 1.0. The issue arises in the User Management Endpoint, specifically within the file '/classes/Users.php?f=save'. This vulnerability allows for unauthorized actions to be performed, and can be exploited remotely.

A vulnerability exists in the GET '/api/v2/connections/{connection_id}' REST API endpoint of Apache Airflow, prior to version 3.2.2. This issue allows authenticated users with Connection-read permission to access unredacted secrets from a Connection's 'extra' JSON blob. The vulnerability arises because certain field names, such as those related to official Slack-provider credentials, were not included in the redaction allowlist, 'DEFAULT_SENSITIVE_FIELDS', leading to the exposure of sensitive information in plaintext. This issue impacts deployments that store credentials in Connection 'extra' blobs and provide Connection-read access to multiple users.

A vulnerability exists in the Apache Directory LDAP API client implementation in versions 2.0.0 through 2.1.7. The issue arises because the client does not verify that the server certificate corresponds to the intended LDAP hostname. Although the code checks the certificate chain against a trusted authority, the lack of endpoint identification allows a valid certificate for an unrelated host to be accepted. This flaw makes the connection susceptible to server impersonation and complete compromise. Exploitation requires a man-in-the-middle (MITM) position on the network, with the attacker presenting a certificate trusted by the client's trust store.

A SQL injection vulnerability has been identified in CodeAstro Ingredients Stock Management System version 1.0. The issue arises in the file 'stock_manager.php' within the 'Ingredients-Stock' directory. The vulnerability is triggered by manipulating the 'txt_search_category' argument, allowing for remote exploitation.

A cross-site scripting (XSS) vulnerability has been identified in Mettle Sendportal versions through 3.0.1. The issue resides within the Campaign Handler component, specifically in the webview directory. The vulnerability allows remote injection of JavaScript into the campaign content, which is then rendered without proper sanitization. This flaw was reported to the project, but no response has been received.

A global buffer overflow vulnerability has been identified in Assimp versions prior to 6.0.4, specifically within the Half-Life 1 MDL Loader component. The issue arises in the 'read_sequence_infos' function of 'HL1MDLLoader.cpp', where the parser reads bone names from a malformed MDL file without proper length validation. This oversight allows an excessively long name to overflow the 'aiString' buffer, leading to an out-of-bounds memory read of 1023 bytes. The vulnerability requires local exploitation and has been publicly disclosed.

A use-after-free vulnerability has been identified in Assimp versions prior to 6.0.4, specifically within the ASE file parser component. The issue arises in the function 'aiNode::~aiNode' located in 'scene.cpp'. When a malformed ASE file is parsed, an invalid node tree is created, leading to a heap-use-after-free condition. This vulnerability must be exploited locally, and a proof-of-concept has been made publicly available.

A heap-based buffer overflow vulnerability has been identified in Assimp versions prior to 6.0.4. The issue arises in the Half-Life 1 MDL Loader component, specifically within the 'extract_anim_value' function of 'HL1MDLLoader.cpp'. The vulnerability is triggered by manipulating the 'num.total' argument, leading to an infinite loop and out-of-bounds memory access. This vulnerability must be exploited locally.

A heap-based buffer overflow vulnerability has been identified in Assimp versions prior to 6.0.4. The issue arises in the Half-Life 1 MDL Loader component, specifically within the 'read_animations' function of 'HL1MDLLoader.cpp'. This vulnerability allows for local exploitation, where the parser writes beyond the allocated memory bounds of an animation array, leading to a crash. The lack of proper boundary validation in the code is the root cause of this vulnerability.

A heap-based buffer overflow vulnerability has been identified in Assimp versions prior to 6.0.4. The issue arises in the Half-Life 1 MDL Loader component, specifically within the 'read_meshes' function of 'HL1MDLLoader.cpp'. This vulnerability allows for local execution exploitation. The problem occurs when the loader processes malformed MDL files that reference non-existent bones, leading to out-of-bounds memory access.

A stored cross-site scripting vulnerability has been identified in the Raisulislamg4 Student Management System. The issue resides in the 'admission_form_check.php' file, where user input in the 'message' field is not properly sanitized before being saved to the database. This unsanitized data is later displayed on the 'admissions.php' page, allowing injected scripts to execute in the context of the administrator's session. The vulnerability affects all versions of the application up to the latest commit on November 1, 2023.

A SQL injection vulnerability has been identified in the user creation handler of the Raisulislamg4 Student Management System. This issue affects versions of the application prior to the latest commit on November 1, 2023. The vulnerability arises in the file 'add_user_check.php', where an unknown function improperly handles the 'role' argument. This oversight allows for remote exploitation, as the application fails to validate user roles before inserting them into the database. The vulnerability has been publicly disclosed and could be actively exploited.

A SQL injection vulnerability has been identified in the Raisulislamg4 Student Management System, specifically in the delete.php file, within versions prior to the latest commit on November 1, 2023. The vulnerability arises from an unknown function that allows for SQL injection through manipulation of the user_id, course_id, teacher_id, student_id, or application_id parameters. This issue can be exploited remotely, as the delete.php script lacks authentication and authorization checks, enabling unauthenticated users to delete various records such as users, courses, teachers, students, and applications. The SQL injection occurs because the SQL queries are constructed by directly concatenating unsanitized GET values, creating an opportunity for attackers to manipulate the SQL query and potentially execute arbitrary SQL commands.

A SQL injection vulnerability has been identified in the login component of the Raisulislamg4 Student Management System, affecting versions prior to the latest commit on November 1, 2023. The issue arises in the file 'login_check.php', where user-supplied input for the username is directly concatenated into an SQL query without proper validation or escaping. This allows attackers to inject arbitrary SQL code, bypassing password authentication and gaining unauthorized access to admin privileges. The vulnerability can be exploited remotely, and the exploit is publicly available.

A denial-of-service vulnerability has been identified in NousResearch Hermes-Agent versions through 2026.4.30. The issue arises in the Webhook Endpoint component, specifically within the Feishu webhook handler. The vulnerability allows remote attackers to send unauthenticated requests with invalid signatures, which consume the same rate-limit bucket as legitimate traffic. This pre-authentication rate-limit exhaustion can lead to dropped or delayed valid webhook events, disrupting automated workflows and message-driven processes.