CVE-2026-123851 is a vulnerability in JetBrains Junie GitHub Action versions before 1.6.4 where prompt injection protection can be bypassed due to incorrect behavior order: validation occurs before canonicalization. This allows an attacker to bypass protections using HTML-encoded characters. The issue is fixed in version 1.6.4.
CGI versions prior to 5.00 for Perl contain an open redirect vulnerability due to improper ordering of validation and canonicalization. The redirect function decodes HTML entities in the URL after validation, allowing a validated URL to be transformed into a different URL that can redirect users to an unintended external host.
Vite versions from 6.4.4 up to but not including 6.4.5 have a vulnerability where the development server improperly evaluates file access restrictions before removing certain loader query parameters. This allows an unauthenticated attacker to bypass deny rules and access sensitive files if the server is network-exposed. The issue is fixed in version 6.4.5.
A path traversal vulnerability (CWE-22) exists in baserCMS versions 5.2.3 before 5.3.2 and 5.4.0 before 5.4.2 in the optional BcThemeFile plugin's Admin API. The issue arises because percent-encoded traversal sequences bypass path normalization checks and are decoded later, allowing an authenticated administrator to write PHP files outside the intended theme directory, such as in the webroot, leading to remote code execution. The vulnerability requires an administrator session and the non-default plugin to be enabled. This flaw has been patched in versions 5.3.2 and 5.4.2.
CVE-2026-93630 is a hostname canonicalization vulnerability in Zimbra Collaboration Suite's email HTML sanitizers. It allows an unauthenticated sender to bypass restrictions on form actions targeting the Zimbra host by exploiting improper validation order before canonicalization. This enables crafted emails to submit authenticated form requests when opened by recipients in Classic mode. The vulnerability affects versions prior to 10.1.21 and does not bypass CSRF-token protections.
fast-uri versions before 2.4.8, from 3.0.0 through 3.1.8, and from 4.0.0 through 4.2.2 improperly percent-decode the URI scheme component using a legacy function, allowing dangerous schemes to be interpreted as executable URLs. This behavior can lead to stored or reflected cross-site scripting (XSS) vulnerabilities by turning inert strings into executable javascript, data, or vbscript URLs. The issue is fixed in versions 2.4.8, 3.1.9, and 4.2.3 and later.
## Summary
When cache interception is enabled, `@opennextjs/cloudflare` can interpret percent-encoded paths differently during middleware matching and cache lookup.
An encoded request may fail to match authorization middleware, then be decoded into the cache key of a protected route. The cached response may consequently be returned without invoking the middleware.
`enableCacheInterception` is disabled by default.
## Impact
A remote unauthenticated attacker may retrieve cached content from routes intended to be protected by middleware.
An application is affected when it:
- explicitly enables `enableCacheInterception`;
- relies on middleware for access control; and
- has a matching cached route.
## Details
Middleware matching previously used the encoded request pathname, while cache interception decoded the pathname before selecting a cache entry.
For example, consider an application with:
- middleware matcher `/admin/:path*`;
- middleware returning `401 Authentication required` for `/admin`;
- a statically generated, cached `/admin` route; and
- cache interception enabled:
```ts
export default defineCloudflareConfig({
incrementalCache: staticAssetsIncrementalCache,
enableCacheInterception: true,
});
```
An attacker can request:
```http
GET /%61dmin
```
The encoded pathname does not match `/admin/:path*`, so the authorization middleware is not invoked. Cache interception then decodes `%61dmin` to `admin` and may return the cached `/admin` response:
```http
HTTP/1.1 200 OK
x-opennext-cache: HIT
Protected content
```
Malformed paths exposed an additional inconsistency. For example:
```http
GET /%61dmin/%ZZ
```
The previous implementation decoded each segment independently. It decoded `%61dmin` to `admin` but retained the malformed `%ZZ` segment, allowing cache lookup to continue using a partially decoded pathname.
## Patches
The fix aligns encoded-path handling across middleware matching and cache lookup, and rejects malformed paths instead of partially decoding them. See the upstream fixes in [opennextjs-aws#1199](https://github.com/opennextjs/opennextjs-aws/pull/1199) and [opennextjs-aws#1200](https://github.com/opennextjs/opennextjs-aws/pull/1200).
Users should upgrade to `@opennextjs/cloudflare@1.20.2` or later.
## Workarounds
If upgrading is not immediately possible for an application:
1. Disable cache interception by removing `enableCacheInterception: true`.
2. Enforce authorization inside protected route handlers rather than relying exclusively on middleware.
3. Reject encoded paths for protected routes at a trusted proxy before they reach the Worker.
Adding individual encoded matcher variants is not a complete workaround because pathnames can have multiple equivalent encodings.
CVE-2026-93326 is a medium severity vulnerability in moby BuildKit affecting versions from 0 up to and including 0.33.0. It involves incorrect behavior order where validation occurs before canonicalization in a Git source build step. This flaw allows a malicious build definition to make a Git repository appear as if it originates from a different remote URL during cloning. However, stricter validations based on commit SHA, commit data, or signatures remain effective.
Apache WSS4J versions prior to 4.0.2, 3.0.6, and 2.4.4 have a vulnerability in the handling of UsernameToken Nonce values. The system stored Nonce values as raw base64 text, but authentication uses decoded bytes, allowing an attacker to replay captured tokens by modifying the base64 encoding without changing the decoded value. This bypasses the nonce replay cache, enabling reuse of tokens until expiration. The issue affects deployments with nonce replay cache enabled and tokens using password digest authentication.
PyJWT versions prior to 2.14.0 accept JWS signature segments with non-canonical Base64URL characters, which do not affect the decoded signature or claims but alter the serialized token and its hash. This can allow bypass of logout or revocation mechanisms that rely on the raw serialized token as a security identity. The issue is not related to signature forgery and requires possession of a valid token. A fix rejecting such non-canonical characters is prepared but not yet released.
Input Leap versions up to 3.0.3, when using the non-default --enable-drag-drop option on Windows or macOS, improperly handle path separators, allowing directory traversal via DDRG messages. This flaw can lead to code execution if an attacker writes a file to a startup directory. The vulnerability is identified as CWE-180 (Incorrect Behavior Order: Validate Before Canonicalize).
CVE-2026-97764 is a vulnerability in django-allauth before version 65.19.4 where the handling of diacritics in login attempts can bypass expected limits on failed login attempts. This occurs due to incorrect ordering of validation and canonicalization processes, allowing attackers to effectively increase the number of allowed failed logins in some configurations.
CVE-2026-95811 is an authorization bypass vulnerability in Lemonldap::NG::Handler for Perl. It affects versions from 2.0.0 before 2.16.10, from 2.17.0 before 2.21.6, and from 2.22.0 before 2.23.4. The vulnerability arises because the handler matches locationRules regular expressions against the raw request URI, while the web server routes on a normalized and percent-decoded path. This mismatch allows an attacker to bypass locationRules restrictions by using equivalent path spellings with percent-encoding, dot segments, or double slashes. Only virtual hosts whose default rule is more permissive than other rules are affected, allowing authenticated users to access URLs that should be restricted by locationRules but only with the permissions of the default rule.
SEP sesam before 5.2.0.24 mishandles User Authorization with MFA. If AD authentication is configured and MFA is enforced, an attacker can create a second OTP access capability. SEP sesam and Active Directory handle username capitalization differently, which may allow multiple SEP sesam user accounts to be created for the same Active Directory (AD) account. Active Directory treats usernames as case-insensitive, while SEP sesam distinguishes between different letter casing. As a result, the same AD user can be represented by multiple SEP sesam user accounts that differ only in username capitalization. When Active Directory authentication is configured and multi-factor authentication (MFA) is enforced, this behavior may allow an additional OTP Authenticator to be registered for the same AD account, reducing the effectiveness of MFA protection.
Incorrect Behavior Order: Validate Before Canonicalize vulnerability in ash-project ash lets an attacker store a case-insensitive string value that violates its length or match constraints.
Ash.Type.CiString.apply_constraints/2 (lib/ash/type/ci_string.ex) validated the max_length, min_length, and match constraints against the value as submitted, while the type case-folds the string (per its casing) for storage and comparison. Because validation ran before folding, an attacker can submit a value whose folded form breaks a constraint but whose original form passes: for example, against a match pattern requiring uppercase, an uppercase value that is stored lowercased persists a value the pattern rejects. The fix case-folds the value at the start of apply_constraints/2, so the constraints are checked against the form that is actually stored.
This issue affects ash: from 1.29.0-rc0 before 3.32.2.
CVE-2026-82481 is a high-severity vulnerability in the mirage cohttp package for OCaml, affecting versions prior to 6.3.0. It involves an incorrect behavior order where validation is performed before canonicalization, leading to a directory traversal flaw. This vulnerability allows an attacker to potentially access unauthorized directories. The CVSS 4.0 base score is 8.7, indicating a significant impact. No known exploits are reported in the wild. The vulnerability is fixed starting from version 6.3.0.
CVE-2026-76203 is a medium severity vulnerability in maalfer Pentestify versions 1.2.0 through 2.3.2. It involves an incorrect behavior order where validation occurs before canonicalization in the CSS sanitizer of the report theme. This flaw allows an authenticated user to craft CSS hex escapes that bypass the sanitizer's blocklist and reconstruct the url() function, enabling forced outbound HTTP requests from other users' browsers. These requests can disclose the victim's IP address and User-Agent information.
CVE-2026-73420 is a critical vulnerability in NextAuth.js affecting the email and magic-link sign-in flow. The default email address normalizer validates the address before applying Unicode normalization, allowing an attacker to exploit Unicode characters that canonicalize to ASCII at-signs. This can cause a misrouting of passwordless sign-in links to attacker-controlled addresses, enabling unauthorized sign-in without victim interaction. The issue is fixed in @auth/core 0.41.3, next-auth 4.24.15, and 5.0.0-beta.32.
AnythingLLM is an application that turns pieces of content into context that any LLM can use as references during chatting. From 1.0.0 to 1.15.0, AnythingLLM's unauthenticated account-recovery flow in server/utils/PasswordRecovery/index.js uses recoverAccount() to deduplicate the raw recoveryCodes values before trimming them, so one valid code submitted twice with different surrounding whitespace can satisfy the two-code check. Each normalized value can also match the same stored hash instead of consuming a distinct hash. An attacker who knows the target username and one recovery code can call POST /api/system/recover-account in multi-user mode, receive a password-reset token, and use POST /api/system/reset-password to take over the account, including an administrator account.
Copier is a library and CLI app for rendering project templates. From 9.5.0 through 9.16.0, percent-encoded parent-directory segments or encoded path separators in a template URL can match a configured trusted repository prefix before an HTTP server or Git transport decodes the path, allowing unsafe template features from a repository outside the trusted prefix to run after user interaction. This issue is fixed in version 9.17.0.