Skip to content

GHSA-mf3j-86qx-cq5j BIT-parse-2026-30925 CVE-2026-30925

Parse Server has Regular Expression Denial of Service (ReDoS) via `$regex` query in LiveQuery

High npm
Severity
0.0 / 10
High · CVSS 4.0
Exploit chance (EPSS)
0.47%
Chance of exploitation in the next 30 days. Higher than 40.50% of scored vulnerabilities.
Known exploited
No
Not in CISA's catalog
Weakness
CWE-1333 Inefficient Regular Expression Complexity
Fix
9.5.0-alpha.14
Upgrade parse-server to this version or later

Description

Impact

A malicious client can subscribe to a LiveQuery with a crafted $regex pattern that causes catastrophic backtracking, blocking the Node.js event loop. This makes the entire Parse Server unresponsive, affecting all clients. Any Parse Server deployment with LiveQuery enabled is affected. The attacker only needs the application ID and JavaScript key, both of which are public in client-side apps.

This only affects LiveQuery subscription matching, which evaluates regex in JavaScript on the Node.js event loop. Normal REST and GraphQL queries are not affected because their regex is evaluated by the database engine.

Patches

Regex evaluation in LiveQuery subscription matching now runs in an isolated VM context with a configurable timeout via a new Parse Server option `liveQuery.regexTimeout, with defaults 100 ms. A regex that exceeds the timeout is treated as non-matching.

The protection adds approximately 50 microseconds of overhead per regex evaluation. For most applications this is negligible, but it can add up if there is a very large number of LiveQuery subscriptions that use $regex on the same class. For example, 10,000 concurrent regex subscriptions would add approximately 500ms of processing time per object save event on that class. Set liveQuery.regexTimeout: 0 to disable the protection and use native regex evaluation without overhead.

Workarounds

Use the beforeSubscribe Cloud Code hook to reject any LiveQuery subscription that contains a $regex operator. Note that this also blocks the LiveQuery startsWith, endsWith, and contains query methods, as they use $regex internally.

// Repeat for each class that is used with LiveQuery
Parse.Cloud.beforeSubscribe('MyClass', request => {
  const where = request.query._where || {};
  for (const value of Object.values(where)) {
    if (value?.$regex) {
      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, '$regex not allowed in LiveQuery subscriptions');
    }
  }
});

References

Affected versions

npm

PackageVulnerableFixed in
parse-server
>= 9.0.0-alpha.1, < 9.5.0-alpha.14
9.5.0-alpha.14
parse-server
< 8.6.11
8.6.11

How to fix

Move to the fixed version or later with your package manager, update the lockfile, and run your tests. If the package only arrives through another dependency, upgrade that dependency first. If none of its releases pulls a fixed version yet, force the version with your package manager's override.

parse-server npm → 9.5.0-alpha.14

npm
npm install parse-server@9.5.0-alpha.14
yarn
yarn add parse-server@9.5.0-alpha.14
pnpm
pnpm add parse-server@9.5.0-alpha.14

Severity breakdown

CVSS 4.0 0.0

CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Attack vector
Network
Attack complexity
Low
Attack requirements
Present
Privileges required
None
User interaction
None
Confidentiality (vulnerable system)
None
Integrity (vulnerable system)
None
Availability (vulnerable system)
High
Confidentiality (subsequent systems)
None
Integrity (subsequent systems)
None
Availability (subsequent systems)
None

CVSS 3.1 7.5

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Attack vector
Network
Attack complexity
Low
Privileges required
None
User interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Weakness

CWE-1333: Inefficient Regular Expression Complexity

The product uses a regular expression with a worst-case computational complexity that is inefficient and possibly exponential.

How to prevent it
  • Architecture and Design: Use regular expressions that do not support backtracking, e.g. by removing nested quantifiers.
  • System Configuration: Set backtracking limits in the configuration of the regular expression implementation, such as PHP's pcre.backtrack_limit. Also consider limits on execution time for the process.
  • Implementation: Do not use regular expressions with untrusted input. If regular expressions must be used, avoid using backtracking in the expression.
  • Implementation: Limit the length of the input that the regular expression will process.

References

Timeline

  1. Published
  2. Last updated by the source
  3. Latest EPSS score
AdvisorySeverityWhy it's related
GHSA-r899-h629-j84r
Parse Server vulnerable to stored XSS via malformed Content-Type bypassing file upload extension blocklist
Low Also affects parse-server
GHSA-97pr-9hgg-3p8r
parse-server: LiveQuery discloses object data to a subscriber across an ACL read-access change
Low Also affects parse-server
GHSA-v8x7-r927-cc93
parse-server: Stored XSS via non-standard file extension bypassing file upload extension blocklist
Low Also affects parse-server
GHSA-cgxm-vr2f-6fj8
parse-server: Denial of service via exponential-time processing of deeply nested query operators
High Also affects parse-server
GHSA-wmwx-jr2p-4j4r
parse-server: Relation `$relatedTo` query bypasses `protectedFields` and owning-object ACL
Medium Also affects parse-server
GHSA-75v4-m273-5j49
parse-server: Endpoints `/login` and `/verifyPassword` disclose MFA secrets and protected fields when `_User` get is denied
Medium Also affects parse-server
GHSA-7wqv-xjf3-x35v
parse-server: Stored XSS via trailing-dot filename bypassing file upload extension blocklist
Low Also affects parse-server
GHSA-p84r-h6rx-f2xr
parse-server: Server option routeAllowList is bypassable through batch sub-requests
Medium Also affects parse-server
Is this in your code?

MergeHarbor checks every repository's dependencies against this database, ranks what matters by exploitability and reachability, routes it to the owning team and opens the fix pull request.

Check your repos with MergeHarbor