---
title: "/verify/math: crafted expressions keep a worker busy…"
description: "GHSA-qgjc-92m3-fcr6: /verify/math: crafted expressions keep a worker busy for minutes, past the #353 cost bounds. Affected and fixed versions of qwed."
url: https://qwedai.tech/security/advisories/ghsa-qgjc-92m3-fcr6
---

[Security](https://qwedai.tech/security) · [Advisories](https://qwedai.tech/security/advisories) · GHSA-qgjc-92m3-fcr6

# /verify/math: crafted expressions keep a worker busy for minutes, past the #353 cost bounds

medium Fixed in 9.0.0 GHSA-qgjc-92m3-fcr6 · Published 6 November 2026

## Impact

A single request to `POST /verify/math` can keep the server busy for minutes or longer. The cost bounds added for #353 (`src/qwed_new/core/safe_parser.py`) assume that a power whose base or exponent names a symbol stays lazy in SymPy. That is not true when the symbol cancels while the expression is evaluated. Separately, `simplify` has no cost bound of its own.

| `expression` | Time on `main` @ `4d0e4845` |
| --- | --- |
| `2+2 = 4` (control) | 0.01s |
| `2**((10000*x/x)**9) = 1` | did not return within 30s |
| `(9**9999*x)**9999 = 1` | did not return within 30s |
| `(x/x*9**9999)**9999` | did not return within 30s (inside the parse) |
| `(x+1)**1000 = 1` | about 20s, in `simplify` |
| `(x+1)**3000 = 1` | about 75s, in `simplify` |
| `(x+1)**9999 = 1` | did not return within 30s |

The `/verify/math` handler is `async def` and calls the parser and `simplify` directly, not in a thread. Reading the code, a request therefore blocks that worker's event loop, so the worker serves no other request until it finishes. Rate limiting counts requests, not CPU time.

## Causes

1.  **Cancellation.**
    -   `x/x` evaluates to 1 while the expression is parsed, so `(10000*x/x)**9` becomes `10000**9`, and SymPy expands `2**(10000**9)` exactly.
    -   SymPy also distributes an integer power over a product, so `(9**9999*x)**9999` raises a 9,543-digit integer to the power 9999.
    -   The static gates read both as symbolic:
        -   `_static_value` returns None for any name;
        -   `_check_pow_cost` returns early when the base is not static (line 198) or the exponent is not (line 208);
        -   `_check_caret_chain_cost` does the same for `^` chains (line 237).
    -   These cases hang inside `safe_parse_expr` itself, so every caller of the parser is affected.
2.  **`simplify` cost.**
    -   A symbolic power within the exponent bound (10,000) is accepted.
    -   `simplify(left - right)` (`core/math_identity.py:50`) and `simplify(parsed)` (`api/main.py:1079`) then expand it. The time grows much faster than the degree: 0.9s at 100, 20s at 1,000, 75s at 3,000.

## Affected

`qwed` (PyPI) through 8.0.0. `safe_parser.py` is unchanged since v8.0.0. Reproduced on `main` @ `4d0e4845`.

Reachable with any valid API key from:

-   `POST /verify/math`, in both the `a = b` form and the plain-expression form;
-   math items in `POST /verify/batch` (`core/batch.py:376` and `:384`). These run in a worker thread, so each one holds a thread rather than the event loop;
-   any local caller of `safe_parse_expr` (cause 1).

## Reproduction

```python
import time
from qwed_new.core.math_identity import math_identity_result  # what /verify/math calls for a = b

for expression in ["2+2 = 4", "(x+1)**1000 = 1", "2**((10000*x/x)**9) = 1"]:
    start = time.perf_counter()
    print(expression, math_identity_result(expression).status, round(time.perf_counter() - start, 1))
```

The last line does not return.

## Patches

Fixed in 9.0.0 ([`413a8d3`](https://github.com/QWED-AI/qwed-verification/commit/413a8d38ccc4ca28be7807622b713f843a7f83ee) ). Upgrade to 9.0.0 or later.

-   `/verify/math` and batch math items run the parse and `simplify` in a pool of worker processes. A job past `QWED_MATH_TIMEOUT_SECONDS` (default 10) is `UNVERIFIABLE` (`math.timeout`), and its worker is killed and replaced. When every worker is busy and the wait list is full, a request is refused at once (`math.capacity`). On Linux each worker has a memory limit (`QWED_MATH_WORKER_MEMORY_MB`, default 2048). Batch math items share a per-job budget (`QWED_BATCH_MATH_BUDGET_SECONDS`, default 120).
-   The handler waits for the pool on threads of its own, so a slow job no longer holds the event loop or the thread pool other routes share.
-   The cost pre-gate parses with the parser's own namespace (see the addendum below).
-   A math setting that is not a finite number in its range stops the server at start, with an error naming the setting.

On 9.0.0, with the default settings, the four expressions in the table that did not return within 30s are `UNVERIFIABLE` (`math.timeout`) after about 10s.

The time limit is on these two routes. `safe_parse_expr` itself, called directly or from other routes that use SymPy in the API process (natural-language math, consensus, the statistics and matrix helpers), has no time limit of its own.

## Workarounds

Upgrade to 9.0.0. On older versions, restrict `/verify/math` and `/verify/batch` to trusted API keys, and run workers under a supervisor that restarts a worker that stops responding.

## Source

Internal review, October 2026. It was found while handling an automated review comment on PR #558, which adds `diff()` and closes the same gap for derivatives only. Not previously disclosed.

## Addendum: the cost pre-gate parses with SymPy's default namespace (re-checked on `main` @ `b74ac00`)

`_check_unevaluated_sympy_cost` (`src/qwed_new/core/safe_parser.py:543-553`) calls `parse_expr(..., evaluate=False)` with SymPy's **default** global namespace. The comment there explains why: a restricted `global_dict` makes `evaluate=False` raise. The cost of that choice is that every public SymPy callable is in scope during the pre-gate, and `evaluate=False` does not stop a call written in the input from running.

Probe, with `sympy.test` replaced by a recorder:

| `expression` | Recorder calls | Result |
| --- | --- | --- |
| `test() + 2 y` | **1** | `SafeParserError` afterwards |
| `test() + 2*y` (control) | 0 | `SafeParserError` |

-   Input that is valid Python goes through the AST allowlist first and never reaches this call with an unknown name.
-   Implicit multiplication (`2 y`) makes `ast.parse` fail, so the input reaches the pre-gate, which then calls `test`. Unpatched, that is `sympy.test`, which starts SymPy's own test suite on the worker. (This probe replaced it with a recorder and did not run it.)
-   No string-construction primitive is reachable through this namespace (none was found), so this is a cost and availability issue, not code execution. It belongs with the other "the cost bound does not hold" causes in this advisory.

Fixed in 9.0.0: the pre-gate parses with the parser's own names, plus the eight classes `evaluate=False` rewrites into (`Symbol`, `Function`, `Integer`, `Float`, `Rational`, `Add`, `Mul`, `Pow`), and empty builtins. On 9.0.0 both probe rows are refused as an unknown function before anything is called (0 recorder calls).

[All advisories](https://qwedai.tech/security/advisories)

Affected and fixed

qwed

Affected <= 8.0.0 Fixed in 9.0.0

Weakness

CWE-400 Uncontrolled Resource Consumption CWE-407 Inefficient Algorithmic Complexity

[View on GitHub](https://github.com/QWED-AI/qwed-verification/security/advisories/GHSA-qgjc-92m3-fcr6)
