Search: client-user-id.com
599 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Medium | 4.3 | EPSS 0.5% | Medium4.3EPSS 0.5%GCVE DatabaseCVE-2026-55653 A double free vulnerability exists in the OpenSSH client used in Red Hat products when operating in FIPS mode during Diffie-Hellman Group Exchange (DH-GEX) key exchange. A malicious SSH server can exploit this flaw to cause the client process to terminate unexpectedly, resulting in a denial of service (DoS). The impact is limited to availability of the SSH client process and does not lead to broader system compromise. Exploitation requires the user to connect to a malicious or compromised SSH server. Mitigation involves avoiding the use of the vulnerable key exchange algorithm in SSH client configurations. | GCVE Database | ||
| High | 8.5 | EPSS 0.3% | CVE-2026-50218Akamai Guardicore Platform Agent · Resource Injection High8.5EPSS 0.3%CVE Database V5CVE-2026-50218 CVE-2026-50218 is a high-severity vulnerability in Akamai Guardicore Platform Agent (GPA) versions before 7.4. The GPA client improperly validates JWT tokens used for seeding, allowing an attacker to inject arbitrary parameters via a spoofed JWT token. This can lead to unauthorized reconfiguration and full compromise of the application's functionality. The attack requires convincing a user to interact with a malicious link or knowledge of the IDP URL used by an enrolled client. A patch is available to address this issue. | CVE Database V5 | ||
| Medium | 5.1 | EPSS 0.2% | CVE-2026-63157Omnispace Agora Project · Cross-site Scripting Medium5.1EPSS 0.2%CVE Database V5CVE-2026-63157 CVE-2026-63157 is a stored cross-site scripting (XSS) vulnerability in Omnispace Agora Project versions before 26.10.0. Authenticated users can inject malicious scripts via an unsanitized 'adress' field in the Links module, which is reflected in an onclick event-handler attribute without proper neutralization of quotes. This vulnerability allows execution of arbitrary scripts in the browsers of users viewing the links list, potentially leading to session hijacking or further client-side compromise. The issue is fixed in version 26.10.0. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.3% | CVE-2026-109952The FreeRDP client 3.0.0 before 3.32.0 does not check a server-selected PROTOCOL_RDSTLS or PROTOCOL_HYBRID_EX against Medium5.3EPSS 0.3%GCVE DatabaseCVE-2026-109952 FreeRDP client versions before 3.32.0 do not properly verify the server-selected PROTOCOL_RDSTLS or PROTOCOL_HYBRID_EX against the client's enabled protocol set during negotiation. This flaw allows a malicious server or man-in-the-middle to downgrade the security protocol, bypass /sec:nla pinning, complete authentication with an all-zero cookie, and obtain the user's cleartext password in the Client Info PDU. EPSS 0.3%Vulnerability | GCVE Database | ||
| Medium | 6.0 | EPSS 0.3% | Medium6.0EPSS 0.3%GCVE Database FreeRDP versions 3.10.0 through 3.32.2 contain a heap buffer overflow vulnerability in the WinPR png_write_data callback. This flaw occurs when a malicious RDP clipboard peer supplies a large CF_DIB image that triggers an out-of-bounds memcpy during PNG conversion, causing the client to crash. The vulnerability requires user interaction and a high attack complexity, with no impact on confidentiality or integrity but causing denial of service. | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database The hridoy-ultimate npm package version 8.0.0 is an unofficial Facebook chat client containing malicious behaviors. It forwards user Facebook credentials and 2FA secrets to a hardcoded third-party server, exposing user accounts to full compromise. Additionally, it dynamically pulls and executes code from an unpinned GitHub repository during installation, allowing arbitrary code execution without integrity checks. A remote-control WebSocket client is present but opt-in and gated by configuration. | GCVE Database | |||
| Medium | 6.5 | EPSS 0.2% | Medium6.5EPSS 0.2%GCVE Database JeecgBoot versions through 3.9.5 have a missing authorization vulnerability in the editThirdAppConfig handler. This flaw allows any authenticated user, including low-privileged attackers, to modify configurations of third-party integrations such as DingTalk, WeCom, or Feishu. Attackers can replace sensitive parameters like client id, client secret, agent id, and corp id, potentially redirecting directory synchronization and messaging to attacker-controlled applications or disrupting these services. | GCVE Database | ||
| Medium | 6.4 | EPSS 0.3% | CVE-2026-102774SureDash (WordPress plugin) · Cross-site Scripting Medium6.4EPSS 0.3%CVE Database V5CVE-2026-102774 SureDash – Community, Courses & Member Dashboard plugin for WordPress versions up to 1.12.1 is vulnerable to a stored DOM-based Cross-Site Scripting (XSS) flaw via the image 'alt' attribute in community post content. Authenticated users with subscriber-level access or higher can inject malicious scripts that execute when other users view the affected pages. The vulnerability arises because entity-encoded payloads bypass server-side filtering and are decoded client-side by GLightbox, leading to script execution. | 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.1 | EPSS 0.4% | CVE-2026-1078080xJacky nginx-ui · Improper Authentication High8.1EPSS 0.4%CVE Database V5CVE-2026-107808 ## Summary nginx-ui supports two second-factor methods — TOTP (OTP) and WebAuthn passkeys — and reports an account as 2FA-enabled when **either** is configured. However, the password login endpoint (`POST /api/login`) only enforces a second factor when a **TOTP secret** is present. An account that has registered a **passkey but no TOTP** is logged in after password verification alone — the passkey is never requested. This silently downgrades a passkey-protected account to single-factor (password-only) authentication. ## Details The account's 2FA policy treats passkeys as a valid factor (`model/user.go`): ```go func (u *User) EnabledOTP() bool { return len(u.OTPSecret) != 0 } func (u *User) EnabledPasskey() bool { /* true if a passkey row exists */ } func (u *User) Enabled2FA() bool { return u.EnabledOTP() || u.EnabledPasskey() } func (u *User) AfterFind(_ *gorm.DB) error { u.EnabledTwoFA = u.Enabled2FA() // exposed to the UI as `enabled_2fa` return nil } ``` But the login handler only checks `EnabledOTP()` (`api/user/auth.go`, `Login`): ```go u, err := user.Login(json.Name, json.Password) ... if u.EnabledOTP() { // <-- only TOTP is enforced if json.OTP == "" && json.RecoveryCode == "" { c.JSON(http.StatusOK, LoginResponse{Message: "The user has enabled 2FA", Code: Enabled2FA}) // 199 user.BanIP(clientIP) return } if _, err = user.VerifyOTP(u, json.OTP, json.RecoveryCode); err != nil { /* ... */ } secureSessionID = user.SetSecureSessionID(u.ID) } // Passkey-only accounts fall through to here and receive a full session token: accessToken, err := user.GenerateJWT(u) ``` No branch requires a WebAuthn assertion during password login when `EnabledPasskey()` is true. The root cause is the mismatch between the **policy definition** (`Enabled2FA()` = OTP **or** passkey) and the **enforcement check** (`EnabledOTP()` only). The same `EnabledOTP()`-only gating in `RequireSecureSession()` (`internal/middleware/secure_session.go`) means passkey-only users are also exempted from step-up on sensitive actions. ## Proof of Concept Tested against nginx-ui built from source (`go build -tags unembed`) on `127.0.0.1:9000`, with WebAuthn configured and a victim account that has a registered passkey and **no** TOTP. The vulnerable code is identical on the production `main` branch (`api/user/auth.go` `Login` gates on `u.EnabledOTP()` only; verified at commit `6c86e5a`, 2026-05-17). Account state advertised by `GET /api/2fa_status`: ```json {"enabled":true,"otp_status":false,"passkey_status":true, ...} ``` Attacker logs in with **password only** (`POST /api/login`, encrypted params as the client normally sends): ``` HTTP 200 {"message":"ok","code":200,"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...."} ``` `code: 200` + a valid JWT = an authenticated session, with the passkey never used. For comparison, the identical account with a TOTP secret instead correctly returns the second-factor challenge: ``` HTTP 200 {"message":"The user has enabled 2FA","code":199} ``` | Account state | `POST /api/login` (password only) | |---|---| | Passkey registered, no TOTP | `code 200` + JWT — **2FA NOT enforced** | | TOTP registered | `code 199` — 2FA challenge enforced | This isolates the defect: the login path enforces OTP but ignores passkeys. ## Impact - Any account protected **only** by a passkey is reduced to password-only authentication. An attacker who obtains the password (phishing, reuse, leak) gains full access despite the registered security key. - In nginx-ui all authenticated users are effectively administrators and the terminal feature grants a host shell, so account takeover leads to full control of the managed nginx instance / host. - Users are given a false sense of security: the UI shows the account as 2FA-enabled while the second factor is not enforced at login. ## Remediation - Gate the second-factor decision on `u.Enabled2FA()` (not `u.EnabledOTP()`) in `Login`, in both SSO callbacks, and in `RequireSecureSession()`. - For a passkey-only user logging in with a password, return a "passkey assertion required" challenge and complete login only after a successful WebAuthn assertion (the `begin_passkey_login` / `finish_passkey_login` flow already exists and should be required as the second step). - Centralize session-token issuance so no login entry point can skip the 2FA decision. ## Affected components - `api/user/auth.go` — `Login` - `model/user.go` — `EnabledOTP`, `EnabledPasskey`, `Enabled2FA`, `AfterFind` - `api/user/2fa.go` — `get2FAStatus` - `internal/middleware/secure_session.go` — `RequireSecureSession` | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.2% | CVE-2026-1078040xJacky nginx-ui · Origin Validation Error Medium5.3EPSS 0.2%CVE Database V5CVE-2026-107804 ## Summary In Nginx UI versions 2.2.0 through 2.5.x, the official bundled reverse-proxy topology did not preserve the external client identity used by Gin. The backend treated the local proxy peer as the client because no trusted proxy was configured, while the proxy supplied the actual address in forwarding headers. ## Impact This has two distinct effects in bundled-proxy deployments: * **IP allowlist enforcement:** management API requests forwarded by the bundled proxy were identified as loopback and could pass the loopback exception even when the external source was not in the configured allowlist. Protected management operations still required valid credentials; this did not grant unauthenticated administrator access. * **Login availability:** failed login attempts from different external sources were attributed to one loopback address. An unauthenticated attacker could therefore trigger the shared temporary login-ban threshold and deny password or OTP login to other users behind the proxy until the ban expired. Existing authenticated sessions were not invalidated. ## Remediation Upgrade to Nginx UI 2.6.0 or later. The fix explicitly trusts only the intended bundled proxy, validates configured trusted proxies, uses the resolved client address consistently, and fails closed when an IP allowlist is enabled but the client address is invalid. Fix commit: https://github.com/0xJacky/nginx-ui/commit/e30e331303fc21cf077a2bea724bd79e66892eaf | 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 | ||
| Medium | 6.5 | EPSS 0.2% | CVE-2026-107336CISA Malcolm · Authentication Bypass by Spoofing Medium6.5EPSS 0.2%CVE Database V5CVE-2026-107336 CVE-2026-107336 is an authentication bypass vulnerability in CISA Malcolm's nginx reverse proxy configuration. The issue arises because a case-insensitive regex matcher allows requests with non-lowercase path segments to bypass a case-sensitive rewrite, leading to unauthenticated access to the Arkime backend. Additionally, the proxy forwards a client-supplied X-Forwarded-User header without overwriting it, and Arkime trusts this header for authentication. This combination allows an unauthenticated attacker to access Arkime with a forged identity. | CVE Database V5 | ||
| Medium | 4.3 | EPSS 0.2% | CVE-2026-107623Red Hat build of Keycloak 26.6 · Missing Authorization Medium4.3EPSS 0.2%CVE Database V5CVE-2026-107623 A serialization bug in the OIDC Dynamic Client Registration component of Red Hat build of Keycloak 26.6 causes the backchannel logout offline token revocation setting to be omitted from responses. This omission silently disables the setting during client updates, allowing offline tokens to remain valid after user sessions are terminated via backchannel logout. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Medium | 4.3 | EPSS 0.4% | CVE-2026-106454Twisted · IMAP wildcardToRegexp() ReDoS Medium4.3EPSS 0.4%GCVE DatabaseCVE-2026-106454 CVE-2026-106454 is a Regular Expression Denial of Service (ReDoS) vulnerability in the Twisted framework's IMAP implementation. The function wildcardToRegexp() improperly compiles user-supplied IMAP wildcard patterns into Python regular expressions without escaping non-wildcard characters. This allows an authenticated IMAP client to craft regex patterns that cause catastrophic backtracking, blocking the single-threaded Twisted reactor and freezing all server I/O. An attacker with valid IMAP credentials can create a mailbox with a specially crafted name and issue a LIST command with a malicious pattern to stall the server for extended periods. The vulnerability is fixed in Twisted version 0.24.0_6 by properly escaping non-wildcard characters before regex compilation. | GCVE Database | ||
| Low | 2.5 | EPSS 0.2% | CVE-2026-106583OpenSSH · In Ssh Low2.5EPSS 0.2%GCVE DatabaseCVE-2026-106583 OpenSSH versions before 10.6 contain a vulnerability where the ssh client allows special characters '$' or '\' in command-line usernames, which can lead to command injection. This flaw enables an attacker to inject arbitrary commands via specially crafted usernames. The vulnerability has a CVSS score of 7.8, indicating a high impact on confidentiality, integrity, and availability. Ubuntu has released patches fixing this issue in OpenSSH client and server packages for multiple LTS releases. Users are advised to update to the fixed package versions to mitigate the risk. | GCVE Database | ||
| Medium | 6.7 | EPSS <0.1% | CVE-2026-79813Hewlett Packard Enterprise (HPE) ClearPass Policy Manager (CPPM) · Improper Privilege Management Medium6.7EPSS <0.1%CVE Database V5CVE-2026-79813 CVE-2026-79813 is a local privilege escalation vulnerability in Hewlett Packard Enterprise ClearPass Policy Manager (CPPM) client software. It allows a low-privileged local user to execute commands with elevated privileges if certain external conditions are met. The vulnerability affects specific versions of CPPM client software. The CVSS score is 6.7, indicating a medium severity level. No known exploits are reported in the wild. No patch or remediation details are provided in the available data. | CVE Database V5 | ||
| High | 7.1 | EPSS 0.3% | CVE-2026-106106quasarframework quasar · Cross-site Scripting High7.1EPSS 0.3%CVE Database V5CVE-2026-106106 Quasar Framework is a framework for building high-performance Vue.js user interfaces. Prior to @quasar/render-ssr-error 2.2.4 and @quasar/app-vite 3.3.0, renderSSRError() in utils/render-ssr-error/src/index.js used diagnostic data from utils/render-ssr-error/src/env.js to serialize process.env, request headers, and cookies into the HTTP page returned by serve.devError(), while the development server listened on all interfaces by default. Any network-adjacent client that reaches an SSR or SSG render failure through this development-only error path can obtain shell environment secrets. The renderer escaped only one exact lowercase script closing-tag spelling, so case variants and valid closing-tag delimiter variants in reflected diagnostic data could terminate the script element and inject markup; executing the injected code in a developer browser additionally requires the payload to accompany that developer's request. This issue is fixed in @quasar/render-ssr-error 2.2.4 and @quasar/app-vite 3.3.0. | CVE Database V5 | ||
| High | 7.1 | EPSS 0.2% | CVE-2026-105867payloadcms payload · Insecure Direct Object Reference High7.1EPSS 0.2%CVE Database V5CVE-2026-105867 ### Impact An authenticated user could overwrite an existing S3 object belonging to another upload collection, bypassing that collection’s access controls and prior file validation. You are affected if ALL of these are true: - Client uploads are enabled for multiple collections that share an S3 bucket. - useCompositePrefixes is not configured or is set to `false`. ### Patches Users should upgrade Payload packages to `>= 3.90.0` or `>= 4.0.0-canary.34`. ### Workarounds Disable client uploads until you can upgrade. | CVE Database V5 |
Page 6 of 34 · 1 duplicate CVE record merged