Search: req.query.base
910 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Medium | 5.3 | EPSS 0.3% | Medium5.3EPSS 0.3%CVE Database V5CVE-2026-107370 CVE-2026-107370 is a vulnerability in the Auth0 auth0-lock library where, under certain conditions involving Active Directory usernames formatted as domains without a local part, authentication requests use the GET method instead of POST. This causes sensitive user form data to be included in the URL query string, potentially exposing it in logs or browser history. The issue affects versions from 10.9.0 up to but not including 13.2.1, and from 14.0.0 up to but not including 15.0.2. The CVSS score is 5.3, indicating a medium severity impact primarily due to confidentiality concerns. There is no information provided about patches or vendor advisories. No known exploits are reported in the wild. EPSS 0.3%Vulnerability | CVE Database V5 | ||
| High | 8.8 | EPSS 0.5% | CVE-2026-16753Lowcoder · Incorrect Authorization High8.8EPSS 0.5%CVE Database V5CVE-2026-16753 CVE-2026-16753 is an incorrect authorization vulnerability in Lowcoder versions 2.1.0 through 2.4.10. It allows an authenticated administrator or developer from one organization to execute library queries belonging to another organization by crafting a request with the victim's library-query identifier. This flaw affects the library-query execution endpoint and can lead to unauthorized access and execution of queries across organizational boundaries. | CVE Database V5 | ||
| Medium | 6.3 | EPSS 0.4% | CVE-2026-110256Finsys dockhand · LDAP Injection Medium6.3EPSS 0.4%CVE Database V5CVE-2026-110256 Finsys Dockhand versions prior to 1.0.19 contain an LDAP injection vulnerability in the tryLdapAuth function. This flaw allows unauthenticated attackers to submit crafted wildcard patterns in login requests to enumerate valid LDAP usernames by measuring response timing. The vulnerability arises because the username input is inserted into the LDAP search filter without proper escaping of special characters. A fix is available in version 1.0.19. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.3% | CVE-2026-110131LiuYuYang01 ThriveX-Server · Missing Authorization Medium6.9EPSS 0.3%CVE Database V5CVE-2026-110131 ThriveX-Server versions up to 4.0 have a missing authorization vulnerability in the GET /api/article and /api/article/{id} endpoints. This flaw allows unauthenticated attackers to access unpublished draft and soft-deleted articles by manipulating query parameters or requesting sequential article IDs. The exposed data includes full titles, descriptions, and content of non-public articles. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.2% | High7.5EPSS 0.2%CVE Database V5CVE-2026-85960 Progress Software Corporation MarkLogic Server versions 11.x before 11.3.7 and 12.x before 12.1.0 contain a Cross-Site Request Forgery (CSRF) vulnerability in the Query Console due to the use of predictable CSRF tokens. This flaw allows a remote attacker to trick an authenticated user into submitting unauthorized requests, potentially leading to execution of server-side code with the user's permissions. | CVE Database V5 | ||
| Medium | 6.3 | EPSS 0.2% | CVE-2026-109302parse-server · Incorrect Authorization Medium6.3EPSS 0.2%CVE Database V5CVE-2026-109302 Parse Server versions 8.2.2 before 8.6.94 and 9.0.0 before 9.10.1-alpha.14 have an authorization flaw in their GraphQL introspection control. The control is applied only to operation text sent directly with a request, but not to operations resolved from Apollo Server's automatic persisted query cache. This allows unauthenticated attackers with the public Application Id and client key to replay cached introspection queries originally made by privileged clients, thereby retrieving the schema including private class and field names. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.3% | CVE-2026-109296open-webui · Insecure Direct Object Reference Medium5.3EPSS 0.3%CVE Database V5CVE-2026-109296 Open WebUI versions before 0.11.4 have an authorization bypass vulnerability that allows authenticated users to access disabled model provider backends by specifying a backend index. This can be done via path segments or query parameters on certain API routes, enabling attackers to trigger requests with configured API keys, read version information, and enumerate backend connections. EPSS 0.3%Vulnerability | CVE Database V5 | ||
| Critical | 9.9 | EPSS 0.6% | Critical9.9EPSS 0.6%CVE Database V5CVE-2026-85955 CVE-2026-85955 is a critical vulnerability in Progress Software Corporation's MarkLogic Server affecting versions 11.x before 11.3.7 and 12.x before 12.1.0. It allows a remote attacker with query-execution access to invoke an XQuery evaluation function without requiring the additional evaluation privilege. This improper privilege management could lead to server-side code execution with elevated permissions, posing a severe risk to confidentiality, integrity, and availability. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-108834Cairo-dock Glx-Dock · Cross-site Scripting Medium5.3EPSS 0.4%CVE Database V5CVE-2026-108834 CVE-2026-108834 is a cross-site scripting (XSS) vulnerability in Cairo-dock Glx-Dock affecting versions 3.0 through 3.4.0. The issue arises from improper handling of the 'p' parameter in the ww_page.php file's Query Parameter Handler component. This vulnerability can be exploited remotely and requires user interaction. Public exploit code is available, but no vendor response or patch has been provided. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Low | 2.1 | EPSS 0.2% | CVE-2026-108808Eleveo Call Recording Software · Use of GET Request Method With Sensitive Query Strings Low2.1EPSS 0.2%CVE Database V5CVE-2026-108808 CVE-2026-108808 is a low-severity vulnerability in Eleveo Call Recording Software up to version 10.3.0. It involves the use of the GET request method with sensitive query strings in the JWT Token Handler component, specifically in the /auth/realms/default/protocol/openid-connect/logout endpoint. The vulnerability arises from manipulation of the id_token_hint argument, which may expose sensitive information via query strings. Exploitation is difficult and requires high complexity. The vendor has not responded to disclosure, and no official patch or remediation is currently available. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| High | 8.6 | EPSS 0.3% | CVE-2026-89285Datalist it (WordPress plugin) · SQL Injection High8.6EPSS 0.3%CVE Database V5CVE-2026-89285 The Datalist it WordPress plugin through 0.0.3 does not sanitize and escape several request parameters before using them to build a SQL query, allowing unauthenticated attackers to perform SQL injection and read arbitrary data from the database. | CVE Database V5 | ||
| Medium | 4.3 | EPSS 0.2% | Medium4.3EPSS 0.2%GCVE Database JeecgBoot versions through 3.9.5 have a missing authorization vulnerability in the loadDatarule handler of SysRoleController. This flaw allows any authenticated user, including low-privileged attackers, to query role data rules by sending a GET request to /sys/role/datarule/{permissionId}/{roleId}. The exposed information includes rule names, columns, conditions, values, and bound rule IDs for any role. The vulnerability has a medium severity with a CVSS score of 4.3. | GCVE Database | ||
| High | 7.5 | EPSS 0.4% | CVE-2026-96662Appointment Booking Plugin – LatePoint | Calendar & Scheduling for WordPress · SQL Injection High7.5EPSS 0.4%CVE Database V5CVE-2026-96662 The Appointment Booking Plugin – LatePoint for WordPress contains a SQL Injection vulnerability in the 'booking[service_id]' parameter. This affects all versions up to and including 5.7.2. The flaw allows unauthenticated attackers to inject additional SQL commands due to insufficient input escaping and query preparation, potentially exposing sensitive database information. The vulnerability has a high severity score of 7.5 and does not require user interaction or privileges to exploit. | CVE Database V5 | ||
| Medium | 6.5 | EPSS 0.3% | CVE-2026-107712WP Booking System – Booking Calendar · SQL Injection Medium6.5EPSS 0.3%CVE Database V5CVE-2026-107712 The WP Booking System – Booking Calendar WordPress plugin is vulnerable to a time-based SQL Injection via the 'current_month' parameter in all versions up to and including 2.1.0.1. This vulnerability allows authenticated users with subscriber-level access or higher to inject additional SQL queries due to insufficient input escaping and lack of proper query preparation. The issue is a regression caused by the removal of a capability check introduced in earlier versions to address a previous vulnerability. This flaw can lead to unauthorized extraction of sensitive database information without requiring user interaction. | CVE Database V5 | ||
| High | 8.8 | EPSS 0.2% | CVE-2026-1078090xJacky nginx-ui · Cross-Site Request Forgery (CSRF) High8.8EPSS 0.2%CVE Database V5CVE-2026-107809 ## Summary Nginx-UI v2.4.3 stores the API JWT in a browser cookie named `token` and the `AuthRequired` middleware accepts that cookie as an authentication source. Because management endpoints are protected by `AuthRequired` and do not enforce a universal CSRF token or Origin/Referer check, a remote attacker can induce a logged-in administrator to submit cross-site state-changing requests. The attacker does not need to read the cross-origin response; the browser-sent cookie is enough to authenticate the request. ## Details The root cause is a trust-boundary failure between browser-managed cookies and API bearer-token authentication. In `app/src/pinia/moudule/user.ts:25-35`, the front end writes the JWT to a `token` cookie when the token changes. In `internal/middleware/middleware.go:16-36`, `getToken` first checks the `Authorization` header and `token` query parameter, then falls back to `c.Cookie("token")`. That fallback causes browser-initiated cross-site requests to carry a valid API credential automatically. The route group in `router/routers.go:87-110` applies `middleware.AuthRequired()` to many management modules, including `config.InitRouter`, `nginx.InitRouter`, `settings.InitRouter`, and backup-related handlers. For accounts without OTP/Passkey, `RequireSecureSession` does not provide a universal second factor for all state-changing operations. A representative sink is `api/config/add.go:68-78`, where an authenticated request writes Nginx configuration with `os.WriteFile` and then calls `nginx.Control(nginx.Reload)`. CORS does not mitigate this issue because preventing cross-origin response reads does not prevent cross-site form or no-cors requests from being sent with cookies. Core vulnerable code path: ```typescript // app/src/pinia/moudule/user.ts:25-35 watch(token, v => { if (v) { cookies.set('token', v, getCookieOptions(86400)) if (!shortToken.value) { void fetchShortToken() } } else { cookies.remove('token', { path: '/' }) shortToken.value = '' } }) ``` The front end stores the authentication token in a `token` cookie. The cookie is created client-side and is not shown here as HttpOnly; it becomes the credential that the back end later accepts through cookie fallback. ```go // internal/middleware/middleware.go:16-36 // getToken from header, cookie or query func getToken(c *gin.Context) (token string) { if token = c.GetHeader("Authorization"); token != "" { return } if token = c.Query("token"); token != "" { if len(token) > 16 { // Long token (base64 encoded JWT) tokenBytes, _ := base64.StdEncoding.DecodeString(token) return string(tokenBytes) } // Short token (16 characters) return token } if token, _ = c.Cookie("token"); token != "" { return token } return "" } ``` `getToken` accepts the `token` cookie as an authentication credential after checking the header and query parameter. That behavior lets a browser-sent cookie authenticate state-changing API requests triggered from another origin. ```go // router/routers.go:87-110 // Authorization required and not websocket request g := root.Group("/", middleware.AuthRequired(), middleware.Proxy()) { debug.InitRouter(g) user.InitUserRouter(g) analytic.InitRouter(g) user.InitManageUserRouter(g) nginx.InitRouter(g) sites.InitRouter(g) streams.InitRouter(g) config.InitRouter(g) template.InitRouter(g) certificate.InitCertificateRouter(g) certificate.InitDNSCredentialRouter(g) certificate.InitAcmeUserRouter(g) dnsapi.InitRouter(g) system.InitPrivateRouter(g) settings.InitRouter(g) llm.InitRouter(g) cluster.InitRouter(g) notification.InitRouter(g) external_notify.InitRouter(g) backup.InitAutoBackupRouter(g) nginxLog.InitRouter(g) upstream.InitHTTPRouter(g) ``` Many management modules, including Nginx, configuration, settings, backup, and user management, are placed behind `AuthRequired`. The cookie fallback therefore protects high-impact state-changing routes, not only read-only endpoints. ```go // api/config/add.go:68-78 err = os.WriteFile(path, []byte(content), 0644) if err != nil { cosy.ErrHandler(c, err) return } res := nginx.Control(nginx.Reload) if res.IsError() { res.RespError(c) return } ``` This representative sink shows why the CSRF is high impact: once authenticated through the cookie fallback, a request can write Nginx configuration content and trigger a reload. ## POC Prerequisites: an administrator is logged in to Nginx-UI and has a browser `token` cookie; the administrator account has not enabled OTP/Passkey, or the chosen target endpoint does not require secure-session proof; the attacker knows the Nginx-UI management URL and can induce the administrator to visit an attacker-controlled page. Reproduction: (1) Host an attacker page at `GET /csrf.html` that automatically submits a cross-site request to the victim instance. (2) The page submits `POST /api/configs` | CVE Database V5 | ||
| High | 8.8 | EPSS 0.3% | High8.8EPSS 0.3%CVE Database V5CVE-2026-107807 ## 1. Vulnerability Summary nginx-ui's `Node.Secret` is a master credential that bypasses all JWT/password authentication for the entire API. The application accepts this credential via a **URL query parameter** (`?node_secret=`), causing it to be recorded in plaintext in HTTP access logs, reverse proxy logs, browser history, and HTTP `Referer` headers. Additionally, the official cluster configuration format embeds node secrets directly into URL query strings stored in `app.ini` and environment variables, creating a systemic credential exposure pattern across the entire cluster deployment model. An attacker who gains read access to any log aggregation system, proxy log, or configuration file can extract the node secret and obtain full, persistent, unauthenticated administrative access to the nginx-ui API — including reading TLS private keys, modifying nginx configurations, and (when chained with Bug #1) achieving OS-level code execution. --- ## 2. Root Cause Analysis ### 2.1 Node Secret Accepted as URL Query Parameter The `getNodeSecret` function reads the credential from the URL query string as a fallback when the `X-Node-Secret` header is absent: [1](#3-0) This function is called in both `AuthRequired()` and `AuthRequiredWS()` middleware, meaning the query parameter bypass works for **all authenticated HTTP and WebSocket endpoints**: [2](#3-1) [3](#3-2) The same pattern is repeated in the WebSocket origin checker, which also reads `node_secret` from the URL: [4](#3-3) ### 2.2 Node Secret Is a Full Authentication Bypass The documentation explicitly states this is by design: [5](#3-4) When the secret matches, the middleware sets the request context to an admin-level init user and calls `c.Next()` — bypassing all JWT validation, session checks, and 2FA: [2](#3-1) ### 2.3 Cluster Configuration Embeds Node Secrets in URLs The official cluster configuration format, documented and used in `app.example.ini`, stores node secrets as URL query parameters: [6](#3-5) The `parseNodeUrl` function extracts the secret from the URL's query string and stores it in the database as the node's `Token` field: [7](#3-6) This means node secrets are embedded in: - `app.ini` on disk (readable by any process with filesystem access) - The `NGINX_UI_CLUSTER_NODE` environment variable (visible in `ps aux`, Docker inspect, Kubernetes pod specs, CI/CD logs) - The SQLite database `nodes` table as the `token` column in plaintext ### 2.4 Node Secret Generation Uses UUID The secret is auto-generated as a UUID v4 if not set: [8](#3-7) UUID v4 has 122 bits of entropy, which is adequate. However, the exposure surface described in this report makes entropy irrelevant — the secret is leaked through operational channels, not brute-forced. --- ## 3. Exposure Surface The following table maps each exposure vector to its source in the codebase: | Vector | How It Happens | Who Can See It | |---|---|---| | **HTTP access logs** | `GET /api/settings?node_secret=xxx` logged by nginx/caddy/apache | Log readers, SIEM operators | | **Application logs** | Gin debug mode logs full request URLs | Server operators, log aggregators | | **Browser history** | Admin uses `?node_secret=` URL directly | Anyone with browser access | | **HTTP Referer header** | Page with `?node_secret=` in URL links to external resource | Third-party servers | | **WebSocket URL logs** | `ws://host/api/ws?node_secret=xxx` logged by proxies | Proxy log readers | | **`app.ini` on disk** | Cluster node URLs contain `node_secret=` | Filesystem readers | | **Environment variables** | `NGINX_UI_CLUSTER_NODE=...&node_secret=...` | `ps aux`, Docker inspect, K8s pod specs | | **CI/CD pipeline logs** | Env vars printed during deployment | CI/CD log viewers | | **Database** | `nodes.token` column stored in plaintext SQLite | DB file readers | --- ## 4. Proof of Concept ### Scenario A: Log-Based Secret Extraction **Step 1 — Attacker gains read access to nginx access logs** (e.g., via a misconfigured log aggregator, a compromised monitoring account, or a separate vulnerability). **Step 2 — Search logs for the pattern:** ```bash grep -oP 'node_secret=[^&\s"]+' /var/log/nginx/access.log # Output: node_secret=a1b2c3d4-e5f6-7890-abcd-ef1234567890 ``` **Step 3 — Use the extracted secret for full API access:** ```http GET /api/settings HTTP/1.1 Host: target:9000 X-Node-Secret: a1b2c3d4-e5f6-7890-abcd-ef1234567890 ``` Response: Full settings JSON including `JwtSecret`, `NodeSecret`, all nginx paths, and all configured credentials. ```http GET /api/nginx/config?filepath=/etc/nginx/nginx.conf HTTP/1.1 Host: target:9000 X-Node-Secret: a1b2c3d4-e5f6-7890-abcd-ef1234567890 ``` Response: Full nginx configuration including any embedded credentials. ### Scenario B: Environment Variable Exposure in Docker/Kubernetes **Step 1 — Attacker reads a Kubernetes pod spec or Docker Compose file:** ```yaml environment: - NGINX_UI_CLUSTER_NODE=http://10.0.0.1:9000?name=node1&node_se | CVE Database V5 | ||
| High | 7.5 | EPSS 0.4% | CVE-2026-86463Apache CXF · Uncontrolled Resource Consumption High7.5EPSS 0.4%CVE Database V5CVE-2026-86463 Apache CXF's FIQL query parser has a vulnerability where it can consume excessive CPU resources when processing long strings without operators. This can lead to denial of service by slowing or stopping other requests. The issue is fixed by limiting FIQL expressions to 4 KiB by default. Users should upgrade to versions 4.2.4, 4.1.9, or 3.6.13 or later to mitigate this risk. | CVE Database V5 | ||
| Medium | 6.3 | EPSS 0.3% | CVE-2026-106428MongoDB C Driver · Out-of-bounds Read Medium6.3EPSS 0.3%CVE Database V5CVE-2026-106428 mongo-c-driver is a project that includes two libraries: libmongoc, a client library written in C for MongoDB. libbson, a library providing useful routines related to building, parsing, and iterating BSON documents. Security Fix(es): An out-of-bounds read in SCRAM authentication response parsing in the MongoDB C Driver can read one byte beyond a fixed-size buffer when processing a malformed server-final message. A server or network intermediary able to provide this message before server-signature verification can cause the application using the driver to terminate. The extra byte is not returned through the protocol.(CVE-2026-106428) An off-by-one error in the BSON bulk document writer in the MongoDB C Driver can write one zero byte immediately past a heap allocation when a document ends at a specific buffer boundary. An actor who can influence the size of documents serialized by an embedding application can corrupt adjacent process memory or terminate the process. Reaching this issue requires the application to use the BSON bulk-writer API and produce a precise cumulative document size.(CVE-2026-106431) The BSON buffer-reservation API in the MongoDB C Driver can record a length smaller than the five-byte BSON minimum. Later append or comparison operations can underflow unsigned length calculations and read or write outside the document buffer. An actor who can influence the length supplied by an embedding application can cause the application to terminate or read or corrupt adjacent process memory. Reaching this issue requires the application to pass an undersized value to bson_reserve_buffer and then perform an affected operation.(CVE-2026-106437) An incorrect calculation in Decimal128 string parsing in the MongoDB C Driver can accept certain over-precision inputs containing leading zeros instead of rejecting them. This produces a value different from the supplied text. An actor who can provide a decimal string to an embedding application, including through Extended JSON parsing, can cause the application to store or use an incorrect numeric value.(CVE-2026-106438) A size check in the client-side authentication path of the MongoDB C Driver can wrap around, so an unusually large user-name value is accepted and copied past the end of a small buffer. A party able to set the driver's connection settings may cause the application that embeds the driver to terminate unexpectedly. Reaching this code requires a build in which the optional external SASL authentication backend is present and a connection configured to use it.(CVE-2026-88035) Improper neutralization of special elements in data query logic in the GridFS component of the MongoDB C Driver can cause a caller-supplied structured file identifier to be interpreted as a query condition rather than as a literal identifier. An authenticated user who can influence the identifier passed by an affected application may obtain stored file content beyond the intended target or cause all GridFS file chunks in the affected bucket to be removed, rendering stored file content unreadable.(CVE-2026-88036) A flaw in libmongoc's SCRAM authentication implementation caused the client to continue the authentication handshake and transmit the client proof even when a nonce mismatch was detected in the server's first message. An unauthorized party with a man-in-the-middle position could exploit this by injecting a crafted server-first-message containing a controlled salt and low iteration count, then capturing the resulting client proof to perform offline password cracking. This vulnerability is mitigated by TLS, which is standard in production deployments.(CVE-2026-93394) A missing lower-bound validation in the bson_new_from_buffer() function of libbson allows an integer underflow when processing BSON data with a zero-length prefix. The function reads a 32-bit document length from the input buffer but does not verify that the value is at least 5 (the minimum valid BSON document size) before using it in an array index calculation. When the length field is zero, the expression used to check the document's null terminator wraps to UINT32_MAX, causing a heap out-of-bounds read that crashes the process. An unauthorized party who can supply crafted BSON input to an application using this API can cause a denial of service.(CVE-2026-93395) | CVE Database V5 | ||
| High | 7.1 | EPSS 0.3% | CVE-2026-106429MongoDB libmongocrypt · Integer Underflow High7.1EPSS 0.3%CVE Database V5CVE-2026-106429 CVE-2026-106429 is an integer underflow vulnerability in MongoDB's libmongocrypt library affecting versions from 1.1.0 up to but not including 1.20.5. The flaw occurs in the KMS endpoint-parsing logic and can cause an allocation failure that terminates the application process. Exploitation requires an authenticated user to modify a key document in the key vault collection or for an application to accept a specially crafted KMS endpoint containing a colon after its path or query during key creation. This vulnerability does not lead to memory corruption or out-of-bounds access. | CVE Database V5 |
Page 11 of 52 · 1 duplicate CVE record merged