tls: report a first handshake that the peer ends with close_notify (Duplex, named pipe, proxy tunnel)

[robobun]

Draft until its self-review returns.

Problem

• A TLS peer answers the ClientHello with a close_notify alert and keeps the stream open. tls.connect({ socket: duplex }) emits no event and stays writable. Proxied fetch and wss wait for their timers.
• Cause: the SSL_ERROR_ZERO_RETURN branch of SSLWrapper::update_handshake_state (src/uws/lib.rs:1061) runs no callback for a first handshake.

Fix

• The branch reports the handshake as failed with the ECONNRESET report of openssl.c, then closes.
• Every owner already handles that pair: the fatal-error branch sends it. node:tls emits end, error ECONNRESET, close, as Node does. Proxied fetch and wss fail with EPROTO and 1015, as direct connections do.
• Verified: 15 new cases in test/js/node/tls/node-tls-duplex-end-verify.test.ts and four other files. 14 fail on main. Node v26.3.0 passes the 9 client cases.

Background

• Bun has two TLS engines. openssl.c drives sockets with a file descriptor. SSLWrapper drives TLS over a Duplex, a named pipe or a proxy tunnel, and reports through on_handshake and on_close.
• close_notify is the alert that ends a peer's write side. BoringSSL returns SSL_ERROR_ZERO_RETURN for it.
• Considered a close with no report: proxied fetch would report ConnectionClosed and a server wrap nothing.

Downsides

• Over a Duplex, a client with a write queued before the handshake gets ERR_SOCKET_CLOSED for close_notify then FIN. Main gives ECONNRESET. node:net: keep 'end' off a destroyed socket and report the read error behind a write in flight #43392 changes that order.
• A server wrap over a Duplex emits error ECONNRESET for close_notify then FIN. Main emits end.
• Release .text +256 B, .rodata +0 B. Per TLS record: 31 instructions before and after, 0 differing.

Notes

Repro (Node v26.3.0 prints end, error ECONNRESET, close; Bun on main prints nothing and the socket stays open)

const tls = require("tls"), { Duplex } = require("stream");
let first = true;
const transport = new Duplex({
  read() {},
  write(chunk, encoding, callback) {
    callback();
    // The peer answers the ClientHello with a close_notify alert and keeps the stream open.
    if (first) setImmediate(() => transport.push(Buffer.from([0x15, 0x03, 0x03, 0x00, 0x02, 0x01, 0x00])));
    first = false;
  },
});
const socket = tls.connect({ socket: transport, servername: "a.test" });
const events = [];
socket.on("end", () => events.push("end"));
socket.on("error", err => events.push("error " + err.code));
socket.on("close", () => console.log(events.concat("close").join(", ")));

What changes, per entry point (debug builds, main against this change, peer sends the alert and keeps the stream open)

Entry point	main	This change	Node v26.3.0
tls.connect({ socket: duplex }), rejectUnauthorized true or false	no event	end, error ECONNRESET, close(true)	the same
The alert inside the transport's write(), readable before tls.connect(), or in two reads	no event	as above	the same
end() on the client, then the alert	no event	as above	the same
The alert in place of the server's last TLS 1.2 flight	no event	as above	the same
TLS in TLS (socket is a TLSSocket)	no event	as above	the same
fetch through a CONNECT proxy	pending until its timer	rejects with EPROTO	n/a
WebSocket (wss) through a CONNECT proxy	pending until its timer	TLS handshake failed, close 1015	n/a
new TLSSocket(duplex, { isServer: true })	no event	error ECONNRESET "socket hang up"	ERR_SSL_UNEXPECTED_MESSAGE before a ClientHello, end after one
tls.Server and http2 secure server, injected connection	no event	tlsClientError ECONNRESET "socket hang up"	tlsClientError ERR_SSL_UNEXPECTED_MESSAGE

The server rows cannot equal Node. BoringSSL reads a close_notify ahead of the ClientHello as the close of the peer. OpenSSL refuses it as an unexpected message.

Measurements (release builds of base 4b02e1031d and of this change, unless a line says debug)

• per-record fast path: 31 instructions before, 31 after, 0 differing, in each of 2 compiled copies of update_handshake_state (llvm-objdump -l on bun-profile). The HTTPClient and UpgradedDuplex instances are one body after identical code folding. traffic_pass (80 instructions) and handle_traffic (33) do not differ. The new branch ran 0 times in 1,000 echoed records and in one proxied fetch (gdb breakpoint, debug build), and 1 time in the repro.
• release binary: +256 bytes .text, +0 bytes .rodata (llvm-size). Stripped bun: 80,848,456 bytes before and after. update_handshake_state +62 bytes and trigger_handshake_callback +38 bytes per copy. SSLWrapper Inner<T>: 224 -> 224 bytes.
• bundled node:net: +0 bytes. http2 upgrade module: +213 bytes.
• per peer-closed handshake: 1 on_handshake and 1 on_close at each of 5 entry points (main: 0 and 0). Scoped debug logs, 3 runs each.
• allocations inside TLSSocket::on_handshake (gdb, debug build, libc malloc): 2 for this report, the stored code and reason. A clean handshake: 162 on main, 162 with this change.
• node:tls client orders over a Duplex equal to Node: 12 of 17 (main: 3). Not equal: three orders with a write queued before the handshake, https.request over a supplied Duplex (it queues its headers), and an untrusted chain with rejectUnauthorized (the existing inline reject).

A write queued before the handshake

Order over a Duplex	main	This change	Node
alert, stream kept open	no event	write cb ERR_SOCKET_CLOSED, error ERR_SOCKET_CLOSED, close(true)	end, error ECONNRESET, write cb ECANCELED, close(true)
alert, then FIN	write cb ERR_SOCKET_CLOSED, end, error ECONNRESET, close(true)	write cb ERR_SOCKET_CLOSED, error ERR_SOCKET_CLOSED, close(true)	as above
FIN only	write cb ERR_SOCKET_CLOSED, end, error ECONNRESET, close(true)	unchanged	as above

The ERR_SOCKET_CLOSED form is what a TCP socket gives on main for a FIN with a queued write. It comes from the close handler in net.ts, which fails the queued write before 'end' reaches the listener that reports ECONNRESET. Issue #43381 tracks it. #43392 and #43250 change that handler, so this change leaves it alone.

Not in this change

• On a TCP socket the other engine reports ERR_SSL_SSL_HANDSHAKE_FAILURE for the same alert, where Node reports ECONNRESET. Issue node:tls: a close_notify alert during the handshake on a TCP socket reports ERR_SSL_SSL_HANDSHAKE_FAILURE, Node reports ECONNRESET #44517 tracks it.
• A server wrap over a Duplex emits no 'close' after a failed handshake, for any failure, also on main. node:net: emit 'close' on a server TLS wrap whose handshake fails on the stream-level engine #38058 has that change.
• The tests for a Windows named pipe (node-tls-namedpipes.test.ts, 2 cases) are not run locally. The named pipe owner uses the same generic code, and cargo check --target x86_64-pc-windows-msvc passes.

Open pull requests that touch the same function

• node:tls: report the fatal TLS alert when a handshake over a Duplex fails #32929: merged by hand with this branch, the merged tree passes cargo check --workspace for linux-x64 and windows-x64. Two conflicts: _http2_upgrade.ts (take the line of node:tls: report the fatal TLS alert when a handshake over a Duplex fails #32929, its tlsHandshakeError already maps ECONNRESET to "socket hang up") and node-http2-upgrade.test.mts (keep both blocks).
• tls: report a refused renegotiation as a protocol failure, not as a certificate verdict #44223: both add a variant to HandshakeOutcome and a constructor to us_bun_verify_error_t. Keep both.
• tls: report a fatal post-handshake SSL error over a Duplex or a named pipe #42324: one test file, keep both blocks.

Test runs

• New cases: node-tls-duplex-end-verify.test.ts (9, node:test, also run on Node), node-tls-connect.test.ts (3, server wraps), node-http2-upgrade.test.mts (1), proxy.test.ts (1), websocket-proxy.test.ts (1), node-tls-namedpipes.test.ts (2, Windows only).
• On a debug ASAN build of this change at base faac63e6d4: the five Linux files pass in full (40, 142, 16, 98 and 44 tests), test/js/node/tls/ passes (499 tests), and 244 of 245 vendored test-tls-* and test-https-* scripts exit 0. The other one needs bun test and fails the same way on main. The rebase onto the current main changed none of the four source files.
• bun run rust:check-all x86_64-pc-windows-msvc aarch64-apple-darwin passes.

[robobun]

^{Updated 11:59 PM PT - Oct 2nd, 2026}

✅ @robobun, your commit daebdb13def226338d6881a703f91802e620eab3 passed in Build #123175! 🎉

---

🧪   To try this PR locally:

bunx bun-pr 44516

That installs a local version of the PR into your bun-44516 executable, so you can run:

bun-44516 --bun

[robobun]

Status: reproduced with the script in the Notes of the description. A client runs TLS over a Duplex. The peer answers the ClientHello with a close_notify alert and keeps the stream open. Main emits no event. This change emits end, error ECONNRESET, close, as Node v26.3.0 does.

[Jarred-Sumner]

Superseded by #44618, which consolidates the open TLS pull requests. This fix and its tests are in there, either as written, rewritten smaller, or merged with the other PRs that patched the same cause (see the "By area" list in that PR). Closing in favor of it.