Debian Patches

Status for nginx/1.22.1-9+deb12u11

Patch Description Author Forwarded Bugs Origin Last update
CVE-2026-32647.patch Mp4: avoid zero size buffers in output.
Previously, data validation checks did not cover the cases when the output
contained empty buffers. Such buffers are considered illegal and produce
"zero size buf in output" alerts. The change rejects the mp4 files which
produce such alerts.

Also, the change fixes possible buffer overread and overwrite that could
happen while processing empty stco and co64 atoms, as reported by
Pavel Kohout (Aisle Research) and Tim Becker.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/a172c880cb51f882a5dc999437e8b3a4f87630cc 2026-02-21
CVE-2026-123640.patch Stream ssl_preread: validate ClientHello extension lengths and uniqueness (CVE-2026-123640)

Validate the extension block and the lengths of parsed extensions.

Debian change:
Combine the ClientHello length checks with the follow-up that rejects
duplicate SNI and ALPN extensions.

Additional upstream commits:
https://github.com/nginx/nginx/commit/1e668b7e856198f89a2eec0b94b54b826eb5c4f7
Aleksei Bavshin <a.bavshin@nginx.com> no upstream, https://github.com/nginx/nginx/commit/63d74d545295faa3d147ef704d740da4805f13f4 2026-09-21
CVE-2026-118899.patch Request body: handle NGX_AGAIN explicitly (CVE-2026-118899)
Return to the event loop when the transport asks to retry, even if the
read event is still marked ready.
Maxim Dounin <mdounin@mdounin.ru> no upstream, https://github.com/nginx/nginx/commit/1b723277aa556ba4c6e40cc8f0f0b465e29c0a13 2024-03-30
CVE-2026-123634.patch Resolver: defer freeing detached contexts until their callback runs (CVE-2026-123634)

Keep finalized contexts alive until the resolver finishes reporting the
results.

Debian change:
Combine the CNAME restart error-handling prerequisite with the fix
for finalizing detached resolver contexts.

Additional upstream commits:
https://github.com/nginx/nginx/commit/338f6231e347c17a07c381802b1bc3c20c55b529
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/7426c29f140c330dd6c6cdfeb2943be1978c69e0 2026-10-28
CVE-2026-123007.patch HTTP/2: account for queued DATA in connection flow control (CVE-2026-123007)

Validate WINDOW_UPDATE against the available send window plus the
queued DATA payload.

Debian backport note:
Keep the queued byte count in the private HTTP/2 connection structure
already used by the CVE-2023-44487 backport. The counter shares the
connection lifetime. Preserve the public ngx_http_v2_connection_t
layout and nginx-dev headers.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/b89c4100bf6762a45e4a6463eaf4b70368277c94 2026-10-29
CVE-2026-27784.patch Mp4: fixed possible integer overflow on 32-bit platforms.
Previously, a 32-bit overflow could happen while validating atom entries
count. This allowed processing of an invalid atom with entrires beyond
its boundaries with reads and writes outside of the allocated mp4 buffer.

Reported by Prabhav Srinath (sprabhav7).
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/b23ac73b00313d159a99636c21ef71b828781018 2026-03-02
CVE-2026-28753.patch Mail: host validation.
Now host name resolved from client address is validated to only contain
the characters specified in RFC 1034, Section 3.5. The validation allows
to avoid injections when using the resolved host name in auth_http and
smtp proxy.

Reported by Asim Viladi Oglu Manizada, Colin Warren,
Xiao Liu (Yunnan University), Yuan Tan (UC Riverside), and
Bird Liu (Lanzhou University).
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/6a8513761fb327f67fcc6cfcf1ad216887e2589f 2026-02-26
CVE-2026-28755.patch Stream: fixed client certificate validation with OCSP.
Check for OCSP status was missed in 581cf2267, resulting
in a broken validation.

Reported by Mufeed VH of Winfunc Research.
Sergey Kandaurov <pluknet@nginx.com> no https://github.com/nginx/nginx/commit/78f581487706f2e43eea5a060c516fc4d98090e8 2026-03-17
nginx-ssl_cert_cb_yield.patch # HG changeset patch
# User Yichun Zhang <agentzh@openresty.org>
# Date 1451762084 28800
# Sat Jan 02 11:14:44 2016 -0800
# Node ID 449f0461859c16e95bdb18e8be6b94401545d3dd
# Parent 78b4e10b4367b31367aad3c83c9c3acdd42397c4

OpenSSL 1.0.2+ introduces SSL_CTX_set_cert_cb() to allow custom
callbacks to serve the SSL certificiates and private keys dynamically
and lazily. The callbacks may yield for nonblocking I/O or sleeping.
Here we added support for such usage in NGINX 3rd-party modules
(like ngx_lua) in NGINX's event handlers for downstream SSL
connections.
no https://github.com/openresty/openresty/blob/master/patches/nginx-1.21.4-ssl_cert_cb_yield.patch
CVE-2023-44487.patch HTTP/2: per-iteration stream handling limit.
To ensure that attempts to flood servers with many streams are detected
early, a limit of no more than 2 * max_concurrent_streams new streams per one
event loop iteration was introduced. This limit is applied even if
max_concurrent_streams is not yet reached - for example, if corresponding
streams are handled synchronously or reset.

Further, refused streams are now limited to maximum of max_concurrent_streams
and 100, similarly to priority_limit initial value, providing some tolerance
to clients trying to open several streams at the connection start, yet
low tolerance to flooding attempts.

Debian backport note:
Keep ngx_http_v2_connection_t and the public ngx_http_v2.h unchanged for
nginx-dev ABI compatibility. Put the new per-connection counters in a
private .hh header.
Maxim Dounin <mdounin@mdounin.ru> not-needed debian upstream https://github.com/nginx/nginx/commit/6ceef192e7af1c507826ac38a2d43f08bf265fb9 2023-10-10
bug-1024605.patch SSI: handling of subrequests from other modules User Ciel Zhao <i@ciel.dev> not-needed debian https://hg.nginx.org/nginx/raw-rev/49e7db44b57c 2022-11-21
bug-973861.patch Lingering close for connections with pipelined requests.
This is expected to help with clients using pipelining with some constant
depth, such as apt[1][2].

When downloading many resources, apt uses pipelining with some constant
depth, a number of requests in flight. This essentially means that after
receiving a response it sends an additional request to the server, and
this can result in requests arriving to the server at any time. Further,
additional requests are sent one-by-one, and can be easily seen as such
(neither as pipelined, nor followed by pipelined requests).

The only safe approach to close such connections (for example, when
keepalive_requests is reached) is with lingering. To do so, now nginx
monitors if pipelining was used on the connection, and if it was, closes
the connection with lingering.

[1] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=973861#10
[2] https://mailman.nginx.org/pipermail/nginx-devel/2023-January/ZA2SP5SJU55LHEBCJMFDB2AZVELRLTHI.html
Maxim Dounin <mdounin@mdounin.ru> not-needed https://hg.nginx.org/nginx/rev/cffaf3f2eec8 2023-02-02
CVE-2025-23419.patch CVE-2025-23419
In OpenSSL, session resumption always happens in the default SSL context,
prior to invoking the SNI callback. Further, unlike in TLSv1.2 and older
protocols, SSL_get_servername() returns values received in the resumption
handshake, which may be different from the value in the initial handshake.
Notably, this makes the restriction added in b720f65 insufficient for
sessions resumed with different SNI server name.

Considering the example from b720f65, previously, a client was able to
request example.org by presenting a certificate for example.org, then to
resume and request example.com.

The fix is to reject handshakes resumed with a different server name, if
verification of client certificates is enabled in a corresponding server
configuration.
Jan Mojžíš <jan.mojzis@gmail.com> no https://github.com/nginx/nginx/commit/13935cf9fdc3c8d8278c70716417d3b71c36140e 2025-02-17
CVE-2026-27654.patch Dav: destination length validation for COPY and MOVE.
Previously, when alias was used in a location with Dav COPY or MOVE
enabled, and the destination URI was shorter than the alias, integer
underflow could happen in ngx_http_map_uri_to_path(), which could
result in heap buffer overwrite, followed by a possible segfault.
With some implementations of memcpy(), the segfault could be avoided
and the overwrite could result in a change of the source or destination
file names to be outside of the location root.

Reported by Calif.io in collaboration with Claude and Anthropic Research.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/a1d18284e0a173c4ef2b28425535d0f640ae0a82 2026-03-16
0003-define_gnu_source-on-other-glibc-based-platforms.patch Use _GNU_SOURCE on GNU/kFreeBSD
Define _GNU_SOURCE not only on GNU/Hurd, but also other glibc-based
platforms including GNU/kFreeBSD.

modified by jan.mojzis@gmail.com
===================================================================
Steven Chamberlain <stevenc@debian.org> yes 2016-07-16
nginx-fix-pidfile.patch Fix NGINX pidfile handling Tj <ubuntu@iam.tj> no debian 2020-06-24
CVE-2024-7347-1.patch Mp4: fixed buffer underread while updating stsz atom.
While cropping an stsc atom in ngx_http_mp4_crop_stsc_data(), a 32-bit integer
overflow could happen, which could result in incorrect seeking and a very large
value stored in "samples". This resulted in a large invalid value of
trak->end_chunk_samples. This value is further used to calculate the value of
trak->end_chunk_samples_size in ngx_http_mp4_update_stsz_atom(). While doing
this, a large invalid value of trak->end_chunk_samples could result in reading
memory before stsz atom start. This could potentially result in a segfault.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/7362d01658b61184108c21278443910da68f93b4 2024-08-12
CVE-2024-7347-2.patch Mp4: rejecting unordered chunks in stsc atom.
Unordered chunks could result in trak->end_chunk smaller than trak->start_chunk
in ngx_http_mp4_crop_stsc_data(). Later in ngx_http_mp4_update_stco_atom()
this caused buffer overread while trying to calculate trak->end_offset.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/88955b1044ef38315b77ad1a509d63631a790a0f 2024-08-12
CVE-2025-53859.patch CVE-2025-53859
diff --git a/src/mail/ngx_mail_handler.c b/src/mail/ngx_mail_handler.c
index 1167df3fb..d3be7f3b3 100644
not-needed debian https://nginx.org/download/patch.2025.smtp.txt
CVE-2026-1642.patch Upstream: detect premature plain text response from SSL backend.
When connecting to a backend, the connection write event is triggered
first in most cases. However if a response arrives quickly enough, both
read and write events can be triggered together within the same event loop
iteration. In this case the read event handler is called first and the
write event handler is called after it.

SSL initialization for backend connections happens only in the write event
handler since SSL handshake starts with sending Client Hello. Previously,
if a backend sent a quick plain text response, it could be parsed by the
read event handler prior to starting SSL handshake on the connection.
The change adds protection against parsing such responses on SSL-enabled
connections.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/784fa05025cb8cd0c770f99bc79d2794b9f85b6e 2026-01-29
CVE-2026-27651.patch Mail: fixed clearing s->passwd in auth http requests.
Previously, it was not properly cleared retaining length as part of
authenticating with CRAM-MD5 and APOP methods that expect to receive
password in auth response. This resulted in null pointer dereference
and worker process crash in subsequent auth attempts with CRAM-MD5.

Reported by Arkadi Vainbrand.
Sergey Kandaurov <pluknet@nginx.com> no https://github.com/nginx/nginx/commit/0f71dd8ea94ab8c123413b2e465be12a35392e9c 2026-03-18
CVE-2026-42945.patch Rewrite: fixed escaping and possible buffer overrun
The following code resulted in incorrect escaping of $1 and possible
segfault:

location / {
rewrite ^(.*) /new?c=1;
set $myvar $1;
return 200 $myvar;
}

If there were arguments in a rewrite's replacement string, the is_args flag
was set and incorrectly never cleared. This resulted in escaping applied
to any captures evaluated afterwards in set or if. Additionally buffer was
allocated by ngx_http_script_complex_value_code() without escaping expected,
thus this also resulted in buffer overrun and possible segfault.

A similar issue was fixed in 74d939974d43.

Reported by Leo Lin.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/524977e7c534e87e5b55739fa74601c9f1102686 2026-04-22
CVE-2026-42946.1.patch Upstream: reset parsing state after invalid status line
Previously, it was possible to start parsing headers with a wrong
parsing state after status line was not recognized, as a fallback
used in the scgi and uwsgi modules.

Reported by Leo Lin.
Sergey Kandaurov <pluknet@nginx.com> not-needed upstream, https://github.com/nginx/nginx/commit/baef7fdac28e4e1fe26509b50b8d15603393e28e 2026-05-18
CVE-2026-42946.2.patch Upstream: fixed parsing of split status lines
If the first response line was split across reads and it didn't appear
a status line, the portion already processed was lost. To preserve ABI,
the change reuses r->header_name_start for proper backtracking on status
line fallback.
Sergey Kandaurov <pluknet@nginx.com> no https://github.com/nginx/nginx/commit/39d7d0ba0799fcff6baee52b6525f45739593cfd 2026-04-29
CVE-2026-40701.patch OCSP: resolve cleanup on connection close
Previously, when a client SSL connection was terminated (typically due to a
timeout) while resolving an OCSP responder, the OCSP context was freed, but
the resolve context was not. This resulted in use-after-free on resolve
completion.

Reported by Leo Lin.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/d2b8d47741820c9fb134c6731ecb40b21f3085b1 2026-04-21
CVE-2026-42934.patch Charset: fix buffer over-read in recode_from_utf8().
When a multi-byte UTF-8 character was split across 3+ single-byte
buffers, the saved bytes continuation path had two related bugs:

ngx_utf8_decode() was called with the last saved-array index instead
of the byte count, causing it to report "incomplete" even when the
sequence was already complete.

The subsequent ngx_memcpy() used that same index as the copy length,
reading past the input buffer boundary.
David Carlier <devnexen@gmail.com> no https://github.com/nginx/nginx/commit/54b7945961b2eaafc480d6b85d9635d0db1c126a 2026-04-12
CVE-2026-9256.patch Rewrite: fix buffer overflow with overlapping captures
When the rewrite replacement string had no variables, but had
overlapping captures, the length of the allocated buffer could be
smaller than the replacement string. This could happen either
when the "redirect" parameter is specified, or when arguments are
present in the replacement string.

The following configurations resulted in heap buffer overflow when
using URI "/++++++++++++++++++++++++++++++":

location / {
rewrite ^/((.*))$ http://127.0.0.1:8080/$1$2 redirect;
return 200 foo;
}

location / {
rewrite ^/((.*))$ http://127.0.0.1:8080/?$1$2;
return 200 foo;
}

Reported by Mufeed VH of Winfunc Research.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/3f135ae2eb60ce376196c898a6c7cb4d774f7068 2026-05-14
FIX-HTTP2bomb.patch Added max_headers directive.
The directive limits the number of request headers accepted from clients.
While the total amount of headers is believed to be sufficiently limited
by the existing buffer size limits (client_header_buffer_size and
large_client_header_buffers), the additional limit on the number of headers
might be beneficial to better protect backend servers.

Requested by Maksim Yevmenkin.

The original patch was modified so that the header count and the limit are
stored in a separate module, ngx_http_header_count_module, instead of the
core module. This allows to avoid changing the size of existing structures
and thus avoid potential ABI breakage and keep all the 3rd party modules
compatible with the new version of nginx without recompilation.
Maxim Dounin <mdounin@mdounin.ru> no <https://freenginx.org/hg/nginx/rev/199dc0d6b05be814b5c811876c20af58cd361fea> 2024-05-24
CVE-2026-48142.patch Charset: fixed another rare buffer overread in recode_from_utf8()
With prerequisites similar to 696a7f1b9, it was possible to gain 1-byte
overread on invalid UTF-8 sequences. The reason is ngx_utf8_decode()
stops advancing the pointer position on the first encountered invalid
byte. The fix is to adjust the advanced pointer up to the whole saved
sequence in this case. Note that this may result in different output
compared to complete invalid UTF-8 sequences, which we can disregard
at this point.

Reported by Han Yan of Xiaomi and p4p3r of CYBERONE.
Sergey Kandaurov <pluknet@nginx.com> not-needed upstream, https://github.com/nginx/nginx/commit/60c4243eb8775d51662a01def8a7dad5d9fb34a7 2026-06-24
CVE-2026-42055.patch Upstream: limit header length for HTTP/2 and gRPC
The change applies the HTTP/2 header length limits to avoid buffer
overflow. See 58a7bc3406ac for details.

Reported by Mufeed VH of Winfunc Research.

The HTTP/2 proxy module was only introduced in v1.29.4 (9bf758ea4d5), so
those changes have been dropped.
Roman Arutyunyan <arut@nginx.com> not-needed backport, https://github.com/nginx/nginx/commit/131be8514da8985b15b74150521afedbf9cc4ea3 2026-06-24
CVE-2026-56434.patch Avoid duplicate subrequest finalization
Previously, if a subrequest was posted twice, it could be finalized in
both calls, excessively reducing r->main->count and potentially leading
to a use-after-free.

The fix is to avoid posting a request if it's already posted. Also,
as a hardening measure, r->write_event_handler is now reset to a no-op
handler during active subrequest finalization.

The problem manifests itself in ngx_http_ssi_filter_module during
unbuffered proxying. If a subrequest is created for an SSI include
statement while the main request has some data postponed by another
include, this subrequest becomes double-posted when the main request
data is flushed. The first post comes from ngx_http_subrequest() and
the second one comes from ngx_http_postpone_filter(). In case of a
quick subrequest finalization, the above mentioned problem happens.

Reported by P4P3R-HAK.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/ddde692db11ab8238e9ca661007f64c9f6d764d2 2026-06-29
CVE-2026-60005.patch Fixed uninitialized memory read caused by stale regex captures.

When ngx_http_regex_exec() reallocates r->captures array, it doesn't update
r->ncaptures value, if regex didn't match. So the next use of unnamed regex
capture triggers uninitialized read and potential buffer overrun.

This config demonstrates the issue:
map test $my_map {
volatile;

~mismatch(.*) 1; # reallocates r->captures in subrequests

default "";
}

server {
location ~(.*) { # sets r->ncaptures
slice 50;

# $1 will read from uninitialized memory in slice subrequests
proxy_set_header Test $my_map$1;

proxy_set_header Range $slice_range;
proxy_pass http://backend;
}
}

The issue was introduced by 746fba0d79c6.
Pavel Pautov <p.pautov@f5.com> no https://github.com/nginx/nginx/commit/b99f804ad38a60ceb07bc429598d5b2c4e70e336 2026-05-15
CVE-2026-42533.patch CVE-2026-42533: script buffer overrun protection (ABI-preserving) Backport of the upstream script buffer overrun protection series, reworked so
that no public structure layout changes and third-party modules built against
nginx-abi-1.22.1-7 keep working without a rebuild.
.
Upstream commits (nginx stable-1.30, released as 1.30.4):
ea47fabf5 Script: simplified copy capture codes.
7ac67898b Script: buffer overrun protection.
78950bdcd Access log: buffer overrun protection.
326b17b00 Script: buffer overrun protection in direct script usage.
97e40e59b Script: avoid garbage at the end of the result string
plus 42f8df65b Add missing bounds check in ngx_{http,stream}_compile_complex_value()
.
The ngx_http_proxy_v2_module hunk of 326b17b00 is dropped: that module does
not exist in 1.22.x.
.
Three deviations from upstream, all required to keep the ABI:
.
1. Upstream adds "u_char *end" to ngx_http_script_engine_t and
ngx_stream_script_engine_t (and "ngx_int_t status" to the latter). The
new member is inserted after "pos", which shifts sp, buf, line, args,
status and request by one pointer (sizeof 88 -> 96 on amd64). Both
structures are part of the public API shipped in nginx-dev, and
NGX_MODULE_SIGNATURE does not cover them, so with --with-compat a module
built against the old header loads without complaint and then corrupts
memory. Verified: stock trixie libnginx-mod-http-set-misc (via
libnginx-mod-http-ndk) and libnginx-mod-nchan segfault the worker on the
first request when loaded into an nginx built with the upstream layout.
.
Instead the buffer end is derived from e->buf, which every script
evaluation entry point already sets to the buffer being written.
ngx_http_script_check_length() falls back to the previous unchecked
behaviour if e->pos does not point into e->buf, so a module driving the
engine in some other way is never failed spuriously.
.
2. Consequently ngx_http_script_run() and ngx_stream_script_run() now set
e->buf, ngx_http_script_regex_end_code() truncates e->buf.len only after
the rewritten arguments have been copied, and the direct script users
(proxy, fastcgi, scgi, uwsgi, grpc, index, try_files) set e.buf.data and
e.buf.len where upstream sets e.end. The stream engine reports failure
via e.ip == ngx_stream_script_exit instead of a new status member; that
pointer is only ever set on error in the stream script engine.
.
3. Upstream moves the value push out of ngx_http_script_complex_value_code()
into a new ngx_http_script_complex_value_end_code(). Modules that emit
ngx_http_script_complex_value_code() themselves and know nothing about the
new code (ngx_devel_kit, and hence set-misc, srcache and lua) would then
never push the value. The push is kept where it is and the end code only
corrects the length of the value already on the stack.
.
The implementation-only declarations are kept in private headers. No existing
public structure layout or function signature changes;
ngx_http_script_engine_t stays at 88 bytes and ngx_stream_script_engine_t at
72 bytes on amd64, with every member at its previous offset.
not-needed upstream backport, https://github.com/nginx/nginx/commit/b767540492e8c79a58bc26034d3bab2f708b7bd1 2026-09-14
CVE-2026-15176.patch Avoid post-rewrite URI to path mapping with alias
Previously, after a "rewrite" had changed the URI, and before a new
location was chosen, the new URI might not match the current location
prefix. This becomes a problem when the location uses "alias", which
is why normally such inconsistency is detected by checking the
r->valid_location flag. Meanwhile this flag only handles the
inconsistency when using the "break" directive or parameter. However
in absence of those, there's still an inconsistency window from URI
change up until the end of the current set of rewrite directives.
URI to path mapping within this window might result in a buffer
overflow if location's prefix was longer than the rewritten URI.

The following example resulted in a buffer overflow with the request
"/foo/1":

location /foo/ {
alias /bar/;
rewrite ^/foo/.*$ /x;
return 200 $request_filename;
}

Alternatively, $request_filename might be used in access log format,
"set", "if", "add_header", etc.

The fix is to reject URI mapping in ngx_http_map_uri_to_path() if the
r->uri_changed flag is set.

CVE-2026-15176
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/ce1da78900b07e72f37a25f55e6606220ac45902 2026-07-10
CVE-2026-93479.patch Script: reserved memory overrun protection in ngx_http_script_run()

In b76754049 buffer overrun protection in script was introduced.
However in ngx_http_script_run() data could still spill over to the
reserved area. This had no visible effects except the return value
which could extend beyond the maximum formatted string size. This
value is however currently unused in the nginx code.

Later in a8289aa69 string length recalculation was implemented to
protect against buffer underwrite. Considering a possible spillover to
the reserved area, the final string size could become larger than the
allocated buffer size. This could later result in writing beyond
the buffer boundaries. Maximum buffer overflow is the size of the
reserved area.

This could affect calculating document root from variables in HTTP
or using access logging in HTTP or Stream. In the case of access
logging a possible impact is limited by an off-by-one write of a null
byte.

Reported by Matt Suiche of Tolmo Inc.

CVE-2026-93479

Debian backport note:
nginx 1.22.1 uses the ABI-preserving CVE-2026-42533 backport, which
derives the writable buffer end from e.buf instead of adding e.end
to the public script engine structures. Set e.buf.len to the script
length without the reserved suffix, while allocating n + len bytes,
so the existing length checks protect that suffix in both HTTP and
stream. No public headers or structure layouts are changed.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/7abb1b4009fdf63e17a1721a932295714eb1fbb7 2026-07-29
CVE-2026-97205.patch Limited the number of pending operations per request
Each pending asynchronous operation holds a reference in
r->main->blocked, an 8-bit field, and the increments were not checked.
With 256 operations pending on a single request the counter wrapped to
zero, after which the request could be freed while those operations
still referenced its pool. This is the same overflow that 4ec67cf86
addressed for r->main->count, and left unaddressed for r->main->blocked.

Operations beyond the limit are now performed synchronously where a
synchronous path exists, and refused otherwise, so that the counter
cannot overflow.

Reported by cyberlancer.

CVE-2026-97205

Debian backport note:
Keep the public ngx_http_request.h unchanged for nginx-dev header
compatibility. Put NGX_HTTP_MAX_BLOCKED in a private .hh header.
The request structure and its 8-bit blocked counter remain unchanged.
Vadim Zhestikov <v.zhestikov@f5.com> no https://github.com/nginx/nginx/commit/587c47aed19ddec799eee953a38837936e585b39 2026-08-17
CVE-2026-123633.patch HTTP/2: mark the connection non-reusable when creating a stream (CVE-2026-123633)

Keep active connections out of the reusable queue. In nginx 1.22.1,
clear the flag after updating the stream count for either client streams
or server pushes.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/0c87dd1db413e440a4e3ef7ee8acc518509e8809 2026-09-17
CVE-2026-113425.patch Mail: keep sessions alive while asynchronous operations are pending (CVE-2026-113425)

Keep the mail session alive while client and upstream operations
are pending.

Debian change:
Combine five upstream commits covering fatal replies, auth_http,
upstream connection setup and SMTP name resolution.

Additional upstream commits:
https://github.com/nginx/nginx/commit/9e811a43119ac902f0d0296fb4afb34bb063cf1b
https://github.com/nginx/nginx/commit/e2d23d45fa93ed236a9cdedcb54271e0a064c4f3
https://github.com/nginx/nginx/commit/5deda780a9d5d1bcd5c6731d3118fa090ae900cc
https://github.com/nginx/nginx/commit/4c5ace9f1d5419334a2e6772a0885ee7ed3d6e91
Vadim Zhestikov <v.zhestikov@f5.com> no upstream, https://github.com/nginx/nginx/commit/df9d8d940ecb83a50b1e55ccc296d0a29cfe774c 2026-11-04
CVE-2026-125283.patch Try files: use the generated path length when stripping the alias prefix (CVE-2026-125283)

Recalculate the length from the script output before moving the path.
This applies to the ABI-preserving script backport already in bookworm.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/b99b6b528b64e93354b5c3453e45701e70c461a8 2026-11-05

All known versions for source package 'nginx'

Links