Hi,

HAProxy 2.6.36 was released on 2026/11/18. It added 48 new commits
after version 2.6.35.

This release is made of a subset of the fixes shipped in 2.8.31.

It starts with four important fixes. A peer could send a message whose
payload did not fit in the channel once the buffer reserve was accounted
for: the stream was then marked as waiting for room although nothing had
been transferred, a state that can never be resolved. The H2, H3 and QUIC
multiplexers treated it as an internal error and killed the worker; they now
report a regular stream error. In the same conditions a hard assertion in
the buffer shift code could fire, which is now relaxed to only reject truly
impossible moves. Crashes could be experienced because of these issues, so
do not delay the upgrade.

This branch also receives QUIC work that was delayed: the handshake no
longer depends on the client resending its ClientHello when it arrives split
into many CRYPTO frames (which is what Chrome does), a transfer no longer
freezes when an empty STREAM frame carrying only the FIN bit has to be
retransmitted, a connection whose stream was released before sending
anything no longer waits for its idle timeout, and "wait-for-handshake" now
really holds the streams until the QUIC handshake is complete.

The rest of the release fixes truncated or stalled HTTP/1 responses, a leak
of file descriptors, two crashes in the resolvers while a name is resolved,
a wrong result in two sample converters, and a few other issues that can
exhaust resources over time. One behaviour change deserves attention:
"cache-use"/"cache-store" rules declared in a "defaults" section, which
never worked and could crash or silently break caching, are now rejected
with an explicit alert at startup, so they must be moved to the proxies.

* buf/muxes: A stream could be left waiting for room that could never come.

  When data could not be moved from a receive buffer to the channel because
  the channel was empty but its reserve left no usable room, the stream was
  flagged as waiting for room even though nothing had been transferred, and
  that state could never be resolved. The H2, H3 and QUIC multiplexers
  detected it as an internal error and aborted the process, so a single
  request with a payload sized against the buffer could kill the
  worker. They now report a stream error, so only the affected stream is
  closed. Under the same conditions, a hard assertion in the buffer shift
  code could also fire; it is relaxed to only reject truly impossible
  moves. Reported with a reproducer and a fix proposal by Adam Crawford; the
  buffer assertion was found by code analysis (Yuqi Qiu and Xiang Li, Nankai
  University).

* cache: A leak and a misplacement of the cache rules were fixed.

  Two cache bugs were fixed: a configuration with two "cache-use" rules that
  both hit leaked an applet and a cache row on every request, until memory
  and cache space were exhausted (any client could trigger it by requesting
  cached objects), and "cache-use"/"cache-store" rules declared in a
  "defaults" section never worked and could crash or silently break caching;
  they are now rejected with an explicit alert at startup, so they must be
  moved to the proxies.

* mux-h2: Host and path based rules could be bypassed on absolute URIs.

  When an HTTP/2 request carried an absolute URI (e.g. "GET
  http://host/path";), the authority and the path sent to the server were not
  extracted the same way as HAProxy's own analyzers do it: the authority
  stopped at the first '/' instead of the first '/', '?' or '#', and the
  userinfo was stripped up to the first '@' instead of the last one. A
  request evaluated by HAProxy for one host or path could therefore be
  delivered to the server with another one, bypassing host and path based
  rules. The mux now splits absolute URIs exactly like the HTTP analyzers
  do.

* quic: A handshake stall could be caused by an unset loss timer.

  An unset loss timer could hide a real one and make the server loop on
  padded Initial packets without ever retransmitting the Handshake data,
  stalling the handshake for minutes with clients that do not arm the
  anti-deadlock probe.  The selection now only considers the packet number
  spaces that have an armed loss time.

* quic: The handshake no longer relies on retransmitting the whole packet.

  A ClientHello may be split across several CRYPTO frames mixed in a single
  QUIC packet, which is what Chrome does to keep its first Initial packet
  opaque to middleboxes. Frames were handled strictly in order, so heavily
  fragmented CRYPTO data could not be buffered and the whole packet was
  rejected and left unacknowledged, unless the client re-emitted its
  ClientHello. The parsing loop now stores the frames it cannot buffer yet
  and parses the packet again, up to three times, so the handshake completes
  on the first attempt. A crash could occur on the error path of this
  reparse loop, which is fixed as well.

* quic: A transfer could freeze when its FIN was lost.

  STREAM frames have a dedicated retransmission path that drops the ranges
  already acknowledged. An empty STREAM frame carrying only the FIN bit
  covers no range at all, so it was discarded on retransmission and the
  client waited forever for the end of the response. Such a frame is now
  kept until its FIN is acknowledged, which also required extending the
  release state of the stream descriptor. A connection could also freeze
  until its idle timeout when a stream was released before sending anything
  (for instance when an error was raised while encoding the response
  headers), because the stream was not removed from the connection's tree.

* quic: "wait-for-handshake" is now effective over QUIC.

  The "wait-for-handshake" http-request action did nothing on a QUIC
  frontend: streams were processed as soon as early data arrived. The QUIC
  multiplexer now holds the streams until the handshake is complete and
  releases them afterwards, so rules placed after this action really run
  against a negotiated connection.

* quic: Packet parsing was reworked before the fixes above.

  These patches do not change the behaviour on their own; they prepare the
  CRYPTO reparse loop by returning a dedicated status from CRYPTO frame
  handling, by allocating the frame descriptor instead of keeping it on the
  stack, and by simplifying the return path of the packet parser.

* h3: A malformed stream could stall a transfer instead of closing it.

  A request stream closed with a standalone FIN before any valid request or
  response was received is now rejected instead of being treated as an empty
  complete message, so it no longer stays accounted and its memory is
  released promptly. The "maxrewrite" limit is now enforced on request
  headers, and the :path pseudo-header is checked for all scheme values (it
  was only checked for http and https, so an invalid path was accepted with
  any other scheme).

* mux-h1: Responses were truncated, and pipelined requests stalled.

  A soft-stop while the last response was still being downloaded released
  the connection and dropped the remaining data, and a pipelined request
  ending exactly at the end of the buffer was not parsed until "timeout
  http-request" (or was rejected with a 414 on a valid request). Both are
  fixed. A 101 response following a "100 Continue" in the same segment was
  also rejected with a 502 because the websocket key was searched in the
  wrong message, and "option idle-close-on-response" is now honoured during
  a soft-stop combined with "close-spread-time".

* mux-h1/h1: Other robustness fixes.

  - "h1-case-adjust" rules now match header names regardless of case, as the
    documentation states.
  - "option accept-unsafe-violations-in-http-{request,response}" remains
    effective on the final response after a 1xx, and after parsing restarted on
    a full output buffer.
  - The Connection/Upgrade header cleanup is now idempotent when the headers
    are received in several parts.
  - In TCP mode, the Upgrade header is no longer modified in flight while HTTP
    sample fetches are evaluated.
  - An FCGI response whose headers arrive in several parts no longer loses its
    content-length.
  - The "h1_open_streams" counter exposed in the stats no longer drifts (and
    can no longer become negative) when a stream cannot be created.
  - "%Ti" and "%Tt" are now correct for streams on an H2/H3 frontend with an H1
    server.

* ssl: Certificate management and wolfSSL builds were fixed.

  When "commit ssl cert" was interrupted (e.g. the CLI client closed the
  connection) after building its new instances in several passes, the freed
  transaction was still referenced: the next certificate command on the same
  certificate could crash the process or corrupt memory. A certificate used
  by more than 10 instances was enough to make the command multi-pass.

  With wolfSSL builds, certificate loading could fail even without any .sctl
  file present: this library provides the custom-extension registration call
  as a stub that always fails, while HAProxy relies on it to load the SCT
  list of a certificate. The capability is no longer advertised for wolfSSL,
  so such builds load their certificates normally again.

* peers: Stick-table updates could be lost or misapplied between peers.

  When an update carrying a "server_key" did not fit in the peer's output
  buffer, the new dictionary entry was kept in the transmission cache while
  the value was never sent. The remote peer then resolved its identifier to
  an unknown or stale entry, losing the server name for the whole
  session. In addition, when a peer reconnected, the sync task deadline was
  overwritten by each peer, so heartbeats to idle peers could be delayed
  until the remote peer closed the connection for inactivity. On the
  stick-table side, the dictionary reference held by "server_key" was only
  released on one destruction path, so memory grew with the number of
  distinct values that went through the table.

* resolvers: Two crashes and an out-of-bounds read were fixed.

  A server of a proxy using a SRV name but without "resolvers" keyword was
  kept attached to the SRV request of the other servers: the first SRV
  response could then crash the process, and a reload with a server state
  file crashed too. Separately, "do-resolve" with a client-controlled value
  such as hdr(host) could build a DNS name with a 256-byte label or an
  embedded NUL, leading to out-of-bounds reads and disclosure of heap data
  in DNS queries.

* mux-fcgi: Responses were truncated for slow clients.

  The FCGI connection timeout was enforced even when streams were still
  attached. With a slow client, HAProxy stops reading from the FastCGI
  server once buffers are full, nothing happens on the connection for a
  while, and it was killed in the middle of the response: the client
  received a truncated response, logged as "SD--", and the server got a
  reset while blocked in write(). The timeout is now only enforced when no
  stream remains attached, as already done for H2; a FastCGI server that
  does not answer at all still gets a 504 after "timeout server".

* fd/connection: A descriptor leak could exhaust "maxsock", and a descriptor
  could be closed twice.

  When an accepted connection could not be prepared, for instance because
  "maxsslconn" was reached, its file descriptor was left open. Incoming
  connections on that listener kept accumulating leaked descriptors even
  after SSL connections were released, until "maxsock" was exhausted, which
  also prevented non-SSL frontends from accepting. Conversely, when a
  connection failed during a health check and the socket had already been
  closed, the descriptor could be closed a second time, closing an unrelated
  file descriptor.

* task: A task could be destroyed twice in master-worker mode.

  A task already flagged as killed but still linked in a queue could be
  destroyed a second time when a forked child cleans the tasks before
  executing (master-worker mode with a "peers" section and a local
  peer). This aborted the child with SIGILL on older branches; the leftover
  window is now closed by ignoring already-killed tasks, which the scheduler
  frees when dequeuing them.

* samples: Two wrong results were fixed in converters.

  "jwt_member_query" only checked one of the two error codes of the base64
  decoder, and the "ungrpc" converter could return a field taken from the
  wrong message when a body carried several gRPC messages.

* cfgparse: Unsupported password hashes are rejected.

  "crypt()" may return NULL or an error token for unsupported hash types (on
  Debian/Ubuntu, strings starting with '*'), and this was not checked, so a
  user or group password using such a hash was accepted at startup and could
  never authenticate. It is now detected during configuration validation.

It is strongly recommended to upgrade to this version. Crashes could be
experienced because of the four fixes listed first. No configuration change
is needed to benefit from them, and none of them alters the protocol or the
configuration syntax: any 2.6.x build can be replaced in place. Deployments
exposing HTTP/2 or HTTP/3 to the Internet should treat this release as
mandatory.

Thanks everyone for your help on this release.

Please find the usual URLs below :
   Site index       : https://www.haproxy.org/
   Documentation    : https://docs.haproxy.org/
   Wiki             : https://github.com/haproxy/wiki/wiki
   Discourse        : https://discourse.haproxy.org/
   Slack channel    : https://slack.haproxy.org/
   Issue tracker    : https://github.com/haproxy/haproxy/issues
   Sources          : https://www.haproxy.org/download/2.6/src/
   Git repository   : https://git.haproxy.org/git/haproxy-2.6.git/
   Git Web browsing : https://git.haproxy.org/?p=haproxy-2.6.git
   Changelog        : https://www.haproxy.org/download/2.6/src/CHANGELOG
   Dataplane API    : 
https://github.com/haproxytech/dataplaneapi/releases/latest
   Pending bugs     : https://www.haproxy.org/l/pending-bugs
   Reviewed bugs    : https://www.haproxy.org/l/reviewed-bugs
   Code reports     : https://www.haproxy.org/l/code-reports
   Latest builds    : https://www.haproxy.org/l/dev-packages


---
Complete changelog :
Aleksandar Lazic (1):
      BUG/MEDIUM: mux-fcgi: do not enforce the timeout on connections with 
streams

Amaury Denoyelle (12):
      MINOR: quic: convert qc_stream_desc release field to flags
      BUG/MEDIUM: quic: handle retransmit for standalone FIN STREAM
      BUG/MINOR: quic: prevent freeze after early QCS closure
      BUG/MEDIUM: quic: support wait-for-handshake
      MINOR: quic: simplify qc_parse_pkt_frms() return path
      MINOR: quic: use dynamically allocated frame on parsing
      MINOR: quic: extend return value of CRYPTO parsing
      BUG/MINOR: quic: repeat packet parsing to deal with fragmented CRYPTO
      BUG/MEDIUM: quic: prevent crash due to CRYPTO parsing error
      BUG/MINOR: h3: enforce maxrewrite on request headers
      BUG/MAJOR: h3: always check :path for all scheme values
      BUG/MEDIUM: h3: reject standalone FIN on invalid request/response

Chris Staite (1):
      BUG/MEDIUM: ssl/cli: reset the ongoing transaction when "commit ssl cert" 
is interrupted

Christopher Faulet (15):
      BUG/MEDIUM: h1: make the Connection/Upgrade headers cleanup idempotent
      BUG/MINOR: h1: keep accepting unsafe violations after a parser reset
      BUG/MEDIUM: h1: don't rewrite the Upgrade header when not cleaning headers
      BUG/MEDIUM: h1-htx: don't stall on messages ending exactly at the 
buffer's end
      BUG/MEDIUM: mux-h1: don't truncate responses on soft-stop
      BUG/MINOR: mux-h1: only reset the session's timing info on the frontend 
side
      BUG/MINOR: mux-h1: fix the open streams counter on stream creation failure
      BUG/MINOR: h1: forget a previous pass' results when parsing headers only
      BUG/MINOR: mux-h1: convert the <from> argument of h1-case-adjust to lower 
case
      BUG/MINOR: mux-h1: search the websocket key in the right message
      BUG/MEDIUM: mux-h1: don't spread-close idle conns with 
idle-close-on-response
      BUG/MEDIUM: connection: don't leak the fd of an accepted connection
      BUG/MEDIUM: resolvers: detach servers without resolvers from the SRV 
request
      BUG/MEDIUM: cache: do not create a second applet when two cache-use rules 
hit
      BUG/MEDIUM: cache: forbid cache rules in defaults sections

Frederic Lecaille (5):
      BUG/MEDIUM: peers: keep the earliest sync task deadline
      BUG/MEDIUM: peers: do not keep a dict entry cached when its update was 
not sent
      BUG/MINOR: sample: realign the ungrpc converter on message boundaries
      BUG/MEDIUM: quic: fix loss time selection in quic_loss_pktns()
      BUG/MINOR: stick-table: release server_key on any stksess destruction

Olivier Houchard (3):
      BUG/MEDIUM: resolvers: reject too long labels when encoding a name
      BUG/MAJOR: mux-h2: split absolute URIs like the HTTP analysers do on 
output
      BUG/MEDIUM: fd: Mark a fd as dead on early close

Remi Tricot-Le Breton (1):
      BUG/MINOR: sample: Fix wrong 'base64urldec' return value check in 
'jwt_member_query'

William Lallemand (6):
      BUG/MEDIUM: task: do not destroy twice the tasks already killed in 
mworker_cleantasks()
      BUG/MINOR: cfgparse: detect unsupported crypt() hashes on Debian/Ubuntu
      BUG/MINOR: ssl: exclude wolfSSL from custom extension support
      SCRIPTS: vtest: allow overriding the Git repository URL
      CI: github: use haproxytech/VTest2 for regression tests
      CI: github: use haproxytech/VTest2 for musl regression tests

Willy Tarreau (4):
      BUG/MAJOR: buf: make the shift distance check less strict in b_move()
      BUG/MAJOR: h3: do not panic on HTX_FL_PARSING_ERROR after htx_xfer()
      BUG/MAJOR: mux-quic: fail on impossible data transfers in rcv_buf()
      BUG/MAJOR: mux-h2: fail on impossible data transfers in rcv_buf()

--
Christopher Faulet



Reply via email to