CVE-2026-108268 is an origin validation error in Privasys enclave-os-virtual affecting versions prior to tdx-v0.2.43 and tdx-gpu-v0.6.27. The vulnerability involves the TDX/GPU RA-TLS certificate issuer omitting a value bound to the active TLS session in the quote ReportData, allowing an attacker with the enclave TLS private key to relay a genuine quote onto another connection. This could cause a relying party to accept an attacker-terminated connection as if it were the attested enclave. The issue is fixed in versions tdx-v0.2.43 and tdx-gpu-v0.6.27.
CVE-2026-108265 is a critical origin validation error in Privasys enclave-os-mini, a Rust-based runtime for Intel SGX enclaves. Before version 0.40.0, the SGX runtime's RA-TLS challenge certificate path omitted a value bound to the active TLS session, allowing an attacker with the enclave TLS private key to relay a genuine quote onto another connection. This could cause a relying party to mistakenly accept an attacker-terminated connection as if it were from the attested enclave. The issue is fixed in version 0.40.0.
CVE-2026-107840 is an uncontrolled resource consumption vulnerability in the Prometheus metrics middleware of jhaals yopass before version 14.7.0. The middleware uses the HTTP request method directly as a label value in metrics, allowing an attacker to send requests with arbitrary method strings. This causes unbounded growth in Prometheus metric time series, leading to memory exhaustion and degraded metrics scrape performance.
CVE-2026-107838 is a high-severity vulnerability in RIOT-OS affecting versions from 2023.07 through 2026.07. It involves unchecked return values in the nanocoap_fileserver component, where failure from _resp_init() is ignored, leading to assertion failures and termination of the affected service or device task when processing specially crafted CoAP requests with large extended tokens. No official fix is available as of the latest review.
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. Prior to 3.8.1, internal/cookies.ParseCookies in internal/cookies/cookies.go handles boundary ASCII control characters and control-only or empty cookie names differently from several backend cookie parsers. An unauthenticated attacker can craft a Cookie header so Coraza indexes or drops a cookie under a different name or value from the backend application, causing rules targeting REQUEST_COOKIES or REQUEST_COOKIES_NAMES to miss application-visible attacker data. Exploitation depends on the backend parser and affected rule scope, and interior control characters with inconsistent backend behavior are outside this advisory's remediation. This issue is fixed in version 3.8.1.
OWASP Coraza WAF is a golang modsecurity compatible web application firewall library. From 3.0.0 until 3.8.0, ProcessResponse in internal/bodyprocessors/json.go passes the ignoreJSONRecursionLimit value of -1 to readJSON, while the recursive guard only stops at zero. A network attacker who can cause an application protected by Coraza to return deeply nested JSON can make response-body processing perform quadratic work, consuming one CPU core for seconds per response within the default ResponseBodyLimit. Request JSON processing is not affected by this specific path because it uses the configured request recursion limit, and exploitation requires response-body inspection to be enabled. This issue is fixed in version 3.8.0.
pyLoad-ng version 0.5.0b3 (develop branch) improperly trusts the client-supplied X-Forwarded-For HTTP header to determine client IP for rate limiting and audit logging. This allows an attacker to bypass rate limits by rotating the X-Forwarded-For value on each request, and to spoof source IP addresses in security logs, undermining IP-based blocking and attribution. The server directly faces clients without a trusted proxy configuration, making the XFF header untrusted input. This vulnerability is rated medium severity.
LobsterAI versions 2026.5.27 through 2026.9.23 have a vulnerability where the uninstallation process can be manipulated via a crafted skill's _meta.json file. This flaw allows an attacker to cause recursive deletion of arbitrary user-writable directories by controlling the openclawSourceDir value. The vulnerability arises because the security scanner does not inspect the _meta.json file during skill installation.
## 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-2026-108108 is an authentication bypass vulnerability in PHPNuxBill through version 2025.3.20. The flaw exists in the RADIUS CHAP verification process where Password::chap_verify() incorrectly returns true even when the supplied response does not match the expected value. This allows attackers who know a valid customer or PPPoE username to log in via MikroTik hotspot or PPPoE CHAP with any incorrect password, gaining unauthorized network access and potentially consuming that customer's plan.
CVE-2026-108106 is a high-severity vulnerability in xerial snappy-java before version 1.1.10.9. It involves unbounded memory allocation when processing compressed input with a large declared uncompressed length. Attackers can exploit this by supplying crafted bytes to various Snappy decompression functions, causing the JVM to allocate up to 2 GB of memory and potentially triggering an OutOfMemoryError, resulting in denial of service.
A flaw was found in libhangul. When parsing Hanja dictionary files, the library fails to verify that an entry contains a valid value alongside its key. By providing a specially crafted dictionary file to an application that queries it, an attacker can trigger an unexpected application crash, resulting in a Denial of Service (DoS).
Crux Agent from 1.9.0 before 2.0.3 uses the full SKA bilocation key as the WireGuard preshared key. When a peering session negotiates use of SHA-512, the key produced is 64 bytes instead of the 32 bytes WireGuard requires. The agent does not validate this size; instead it attempts to use the `wg set` command to update the live tunnel, and write the invalid key to the WireGuard configuration file. The update fails, so the live tunnel keeps using its previous preshared key until the tunnel is shut down. The tunnel will fail to start when restarted.
For a peer which has never successfully negotiated a 32-byte bilocation key in a Crux C2 organization which has the "Enforce SKA Use" setting turned off, no preshared key will be set for the tunnel. Therefore, an attacker who is able to intercept and store the peer's traffic, and has access (or will have access) to a cryptographically relevant quantum computer, will be able to decrypt the tunnel.
CVE-2026-94447 is a high-severity vulnerability in the Go toolchain's cmd/go component involving improper validation of integrity check values. A user working within a malicious Go project that defines a bogus golang.org/toolchain go.sum entry and uses a malicious GOMODPROXY can bypass the intended checksum verification. The issue is addressed by ensuring that golang.org/toolchain always fetches the canonical checksum from the network.
CVE-2026-94444 is a high-severity vulnerability in the Go toolchain's cmd/go module related to improper validation of integrity check values. It allows a user working inside a malicious Go project that defines a fake golang.org/fips140 module and connects to a malicious GOMODPROXY to have an arbitrary module served in place of the legitimate one. The issue is addressed by unpacking and verifying the trusted ziphash for the bundled golang.org/fips140 module to ensure its integrity.
SumatraPDF is a multi-format reader for Windows. In 3.7.0.22298, LitParseHeader() in src/LitDoc.cpp computes the attacker-controlled hdrLen + nPieces * 16 section offset using signed 32-bit arithmetic without validating the complete result. When the component values make that aggregate calculation overflow to a negative value, pointer construction reaches an invalid read in LitU32(), causing deterministic application termination. The supplied evidence does not demonstrate code execution, information disclosure, arbitrary read, or integrity impact. No fixed version is available as of this review.
SumatraPDF is a multi-format reader for Windows. In 3.7.0.22298, src/MobiDoc.cpp narrows the untrusted unsigned mobiHdr.hdrLen field to a signed integer for validation; values above INT_MAX become negative and bypass the upper-bound check. When the EXTH flag is set, the original unsigned value is reused as a pointer offset, causing DecodeExthHeader() to read beyond the record buffer. Opening a crafted MOBI file can reliably terminate the application with a native access violation; no code execution, information disclosure, or integrity impact has been demonstrated. No fixed version is available as of this review.
CVE-2026-107728 is an incorrect authorization vulnerability in the strawberry-graphql library affecting versions from 0.217.0 up to but not including 0.326.1. The flaw occurs when a synchronous field resolver uses a custom permission whose has_permission() method is defined as a normal function returning an awaitable object. Because the awaitable is not awaited, its inherently truthy value incorrectly allows access to protected resolvers even when permission should be denied. This issue does not affect async has_permission() methods or synchronous permissions returning booleans. The vulnerability is fixed in version 0.326.1.
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)