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'
- 1.30.6-4 (sid)
- 1.30.6-3 (forky)
- 1.26.3-3+deb13u11 (trixie-security)
- 1.26.3-3+deb13u10 (trixie-proposed-updates)
- 1.26.3-3+deb13u7 (trixie)
- 1.22.1-9+deb12u11 (bookworm-security)
- 1.22.1-9+deb12u9 (bookworm)
