Three things have to be true for the pattern to exist.
First, a state variable whose value a downstream consumer reads through arithmetic that presumes an invariant. The reader does not check the invariant; it treats the invariant as a type-level property of the variable. In NGINX CVE-2026-123007, ngx_http_v2_state_window_update computes the admitted delta as NGX_HTTP_V2_MAX_WINDOW - h2c->send_window, and the subtraction is only well-defined while send_window stays at or below NGX_HTTP_V2_MAX_WINDOW. The result is reused by further arithmetic, interpreted later as an (off_t) byte count, and ultimately passed as a length into a vectorised memcpy. The arithmetic's result is correct exactly on the range the invariant describes, and silently wrong on any input the invariant forbids.
Second, a primary writer whose debit logic holds the invariant. The writer deducts what it is about to commit from the shared variable, and the deduction happens inside the path that commits the spend. From the primary writer's local correctness argument, the invariant is unviolable: it reserves what it is about to use, and the ceiling is what gates the reservation. In the NGINX exhibit, ngx_http_v2_send_chain reserves credit before the frame leaves the queue. The author of that function does not install a ceiling check after the deduction because the deduction is the ceiling. A reviewer who audits only ngx_http_v2_send_chain concludes the counter cannot exceed the maximum.
Third, a refund writer whose add-back logic depends on the primary writer having actually committed. The refund exists because the primary writer may fail to flush: the connection may die, the stream may reset, the operation may be cancelled before the reserved capacity is consumed. Its purpose is to return reservations to the pool. Its local correctness argument is that the amount it is restoring was reserved by a prior writer who respected the ceiling, so adding the amount back cannot exceed a value the ceiling has already approved. The argument is sound exactly when the prior commit happened. The argument has no defence against the case where the refund reaches the variable along a cleanup route the primary writer never traversed with its matching debit.
Attackers deliver that case. In the NGINX exhibit, the operator sends a SETTINGS_INITIAL_WINDOW_SIZE the protocol disallows; the connection resets; ngx_http_v2_filter_cleanup walks every queued DATA frame and refunds frame_size back onto send_window for each one; the flushes never happened. The counter climbs past NGX_HTTP_V2_MAX_WINDOW. The validator's subtraction underflows into an enormous positive delta; a tailored final WINDOW_UPDATE drives the field across the signed midpoint; ngx_http_v2_send_chain reads it as (off_t) and passes a negative limit into glibc's AVX memcpy.
The pattern repeats across any accounting ledger with reservable capacity: token buckets, flow-control windows, connection credits, pool budgets, transaction locks. The structural condition is that one counter carries two meanings the code never separated. The counter the consumer reads is "capacity already granted to the peer," which has a ceiling. The counter the refund writes is "pending reservations that may still return to the pool," which does not have the same ceiling because a reservation that was never spent is not capacity granted to anybody. One variable is being asked to serve both accounting roles. The primary writer stays correct because its role is the consumer's role. The refund writer stays correct against its own role but writes to the consumer's variable.
The fix is not a predicate at the refund site. A check at the refund that rejects writes which would push the counter past the ceiling closes the demonstrated chain and leaves the pattern in place: the counter now rejects legitimate refunds whenever an attacker has already engineered the state near the ceiling, converting the write-path bug into a liveness bug. The structural fix is a ledger column. A second variable accumulates pending reservations without needing to respect the ceiling the consumer reads, and a reconciliation step moves the amount from the refund ledger to the consumer ledger only along the code path that would have committed the primary writer's spend. The NGINX patch adds send_queued for exactly this purpose: the refund writes to send_queued, the validator reads send_window, and the two are reconciled by the code path that would have debited the spend. The audit-readable scope of the patch is one new field. The pattern it closes is the collapse of two accounting roles into one counter.
What distinguishes the class from its neighbours is where the enforcement disagreement lives. No validator function ran once at startup while the runtime rewrote the state behind it (Validated At Boot); there is no validator in the usual sense, and the state is not configuration. No predicate was written narrower than the dangerous range (Sign Bit Is Not Overflow, Limit Check As Equality); no predicate was written at the write site at all, because the write site's local reasoning precluded needing one. No two implementations of the same contract diverged on whether to import a shared check (Parallel Implementation Gap); the refund path and the primary path are complementary, not parallel, and no shared check exists to be imported. The discipline this pattern asks a reviewer to apply is to recognise, at any accounting site with reservable capacity, that the counter which the consumer reads and the counter which refunds write back to may be the same variable by accident.