Debian Patches

Status for nginx/1.26.3-3+deb13u11

Patch Description Author Forwarded Bugs Origin Last update
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
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-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
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
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-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-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
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-40460.patch QUIC: avoid assigning unvalidated address to new streams
Previously, when a client migrated to a new address, new QUIC streams
received this address before validation. This allowed an attacker to
create QUIC streams with a spoofed address.

Reported by Rodrigo Laneth.
Roman Arutyunyan <arut@nginx.com> no https://github.com/nginx/nginx/commit/5461e8bbc09230a4cf8e3d7737c176ae69b091f1 2026-04-30
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
Upstream-limit-header-length-for-HTTP-2-and-gRPC.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.
[Salvatore Bonaccorso: Drop changes for HTTP/2 proxy module which only got
added in release-1.29.4]
Roman Arutyunyan <arut@nginx.com> no debian https://github.com/nginx/nginx/commit/131be8514da8985b15b74150521afedbf9cc4ea3 2026-06-02
Charset-fixed-another-rare-buffer-overread-in-recode.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> no debian https://github.com/nginx/nginx/commit/60c4243eb8775d51662a01def8a7dad5d9fb34a7 2026-06-01
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.26.3-1 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.26.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.26.3 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-95101.patch HTTP/3: kept the skipped frame length separate from data length

ngx_http_v3_parse_data() stored the remaining length of a skipped
(unknown) frame in st->length -- the same field the request body
filter uses for the number of DATA payload bytes to pass on as
request body. When an unknown frame was split across parser
invocations, the skip was interrupted with st->length holding the
skip remainder; on the next buffer the body filter, which calls
the parser only while st->length == 0, treated that remainder as
request body.

When proxying, this could result in sending unframed bytes, potentially
allowing for bypass of client_max_body_size, which is enforced only on
the DATA path, or an injection.

The fix is to keep unknown frame payload in a separate st->skip counter.

Reported by Hansol Lee of GOTROOT.

CVE-2026-95101

Debian backport note:
Keep ngx_http_v3_parse_data_t unchanged for nginx-dev ABI compatibility.
Reuse st->type as the skip counter while in sw_skip: the unknown frame
type is no longer needed, and sw_type overwrites it for the next frame.
Keep st->length zero while skipping, as in the upstream fix.
Vadim Zhestikov <v.zhestikov@f5.com> no https://github.com/nginx/nginx/commit/90b30edffea4f427608c36e3849643b6f9841bc4 2026-07-22
CVE-2026-97629.patch SSL: synced all session ticket keys to the worker process
The per-worker ticket key mirror is allocated with three slots
(ngx_array_push_n(keys, 3)), matching the shared memory
ticket_keys[3] array and the decrypt callback, which scans all
keys->nelts slots by key name. Key rotation, however, synced
only two slots from shared memory, leaving the third slot's
name, hmac_key, and aes_key uninitialized.

A ticket whose key name matched the uninitialized slot (which
holds unspecified pool memory, all zero in the best case) could
therefore be HMAC-verified and decrypted with uninitialized key
material, allowing a forged session.

Sync all keys->nelts slots, as ngx_ssl_ticket_keys_cleanup()
already assumes.

Reported by PhiNode Labs.

CVE-2026-97629
Vadim Zhestikov <v.zhestikov@f5.com> no https://github.com/nginx/nginx/commit/fdedba031bf1ad6a80c61b1aec1418d1a87ae296 2026-07-22
CVE-2026-123633.patch HTTP/2: reset reusable connection status on stream creation
Previously, an HTTP/2 connection could be reusable while having streams.
This could result in an attempt to drain the connection while processing
one if its streams, for example when connecting to an upstream. After
recognizing that the connection has streams, an attempt to send the
GOAWAY frame was made. On send failure, the connection was immediately
closed and its pool released. This triggered a use-after-free up the
stack.

Having an HTTP/2 connection with streams registered as reusable became
possible after 76672e650. A connection with no streams and a partial
frame read from client was registered as reusable to avoid DoS attacks.
So if a client sends only the first HEADERS frame byte, the connection
becomes reusable. Later, when the remaining HEADERS bytes are received
and a new stream is created, the reusable status is not reset until the
connection becomes idle.

Fix is to mark the connection non-reusable upon stream creation.

Reported by Albert @ Vexera AI.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/0c87dd1db413e440a4e3ef7ee8acc518509e8809 2026-09-17
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-120967.patch Stream: client SSL certificates were not checked with SNI
If the SSL handshake completed in the first call of
ngx_stream_ssl_handler(), the client certificate was verified using the
configuration of the default server, rather than the virtual server
selected by SNI during the handshake.

The problem appeared in d21675228 (1.25.5). It is similar to the one
fixed in 620c9a4c4.

The fix is to re-read the server configuration before verifying the
client certificate.

Reported by CERT.PL.
Vadim Zhestikov <v.zhestikov@f5.com> no upstream, https://github.com/nginx/nginx/commit/77f90f1c0cbf79145e5667b7e171f8766ccb6765 2026-10-14
CVE-2026-118899.patch Handle NGX_AGAIN explicitly when reading request bodies (CVE-2026-118899)

Stop reading when the transport asks to retry, even if the read event
is still marked ready.

Debian change:
Combine the request-body NGX_AGAIN fix with its HTTP/3 follow-up.

Additional upstream commits:
https://github.com/nginx/nginx/commit/d1640655f46c5a2d32fefc2c818583f203e47536
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:
Store the queued byte count in a private connection allocation that
embeds ngx_http_v2_connection_t as its first member. The counter has
the lifetime of the connection, and the exported header and structure
layout stay compatible with existing nginx-dev modules.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/b89c4100bf6762a45e4a6463eaf4b70368277c94 2026-10-29
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-121810.patch QUIC: avoid main connection reuse after creating a stream
Previously, ngx_quic_create_stream() cleared the main connection's
reusable flag and then called ngx_get_connection() before inserting the
new stream into the tree. If the worker was low on free connections,
the drain inside ngx_get_connection() could close an idle stream of the
same main connection. Since the new stream was not in the tree yet,
that close found no remaining streams and marked the main connection
reusable again. Once reusable, the connection could later be drained
while processing one of its streams, for example when connecting to an
upstream, freeing it while still in use.

Fix is to insert the new stream into the tree before calling
ngx_get_connection(), so the main connection is not considered idle.

Reported by Xint.io.
Roman Arutyunyan <arut@nginx.com> no upstream, https://github.com/nginx/nginx/commit/c58d2a22d12350766185c94f2245bf4be5bcfb7d 2026-11-01
CVE-2026-125283.patch Try files: fix uri formating in case of script underwrite
Previously, if try_files was used with alias, and the script produced
a string smaller than the predicted size, then an integer underflow
could happen which resulted in buffer overrun.

Fix is to recalculate the length after running the script.

A similar length recalculation exists in ngx_http_index_module.
It was added by 25f920eca when fixing script overruns.

Reported by Marc Luchian & Liviu-Alexandru Bud.
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