Jarred-Sumner · Oct 10, 2026 · Oct 5, 2026 · Oct 6, 2026 · Oct 6, 2026 · Oct 6, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/docs/runtime/environment-variables.mdx b/docs/runtime/environment-variables.mdx
@@ -208,12 +208,15 @@ Bun reads these environment variables to configure aspects of its behavior.
 | Name                                     | Description                                                                                                                                                                                                                                                                                                                                                                   |
 | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `NODE_TLS_REJECT_UNAUTHORIZED`           | `NODE_TLS_REJECT_UNAUTHORIZED=0` disables SSL certificate validation. Useful for testing and debugging, but be very hesitant to use it in production. Node.js introduced this variable; Bun keeps the name for compatibility.                                                                                                                                                 |
+| `SSL_CERT_FILE`                          | Path to a PEM file of CA certificates that Bun trusts in addition to its bundled root certificates. If unset, Bun reads `/etc/ssl/cert.pem`. If set to an empty string, Bun reads no file.                                                                                                                                                                                    |
+| `SSL_CERT_DIR`                           | Directories of CA certificates that Bun trusts in addition to its bundled root certificates, each file named by its subject hash (`<hash>.0`, as `openssl rehash` creates). Separate directories with `:` (`;` on Windows). If unset, Bun reads `/etc/ssl/certs`.                                                                                                             |
 | `BUN_CONFIG_VERBOSE_FETCH`               | If `BUN_CONFIG_VERBOSE_FETCH=curl`, then fetch requests log the URL, method, request headers and response headers to the console. This also works with `node:http`. `BUN_CONFIG_VERBOSE_FETCH=1` is equivalent to `BUN_CONFIG_VERBOSE_FETCH=curl` except without the `curl` output.                                                                                           |
 | `BUN_RUNTIME_TRANSPILER_CACHE_PATH`      | The runtime transpiler caches the transpiled output of source files larger than 4 KB, which makes CLIs using Bun load faster. If `BUN_RUNTIME_TRANSPILER_CACHE_PATH` is set, Bun writes the cache to that directory. If it is set to an empty string or the string `"0"`, caching is disabled. If it is unset, Bun writes the cache to the platform-specific cache directory. |
 | `TMPDIR`                                 | Bun occasionally requires a directory to store intermediate assets during bundling or other operations. If unset, defaults to the platform-specific temporary directory: `/tmp` on Linux, `/private/tmp` on macOS.                                                                                                                                                            |
 | `NO_COLOR`                               | If `NO_COLOR=1`, then ANSI color output is [disabled](https://no-color.org/).                                                                                                                                                                                                                                                                                                 |
 | `FORCE_COLOR`                            | If `FORCE_COLOR=1`, then ANSI color output is forced on, even if `NO_COLOR` is set.                                                                                                                                                                                                                                                                                           |
 | `BUN_CONFIG_MAX_HTTP_REQUESTS`           | Sets the maximum number of concurrent HTTP requests sent by fetch and `bun install`. Defaults to `256`. Lower it if you run into rate limits or connection issues.                                                                                                                                                                                                            |
+| `BUN_CONFIG_WS_CLOSE_TIMEOUT`            | Sets how many seconds a `WebSocket` client waits for the server to close the connection after the closing handshake. Bun then closes it. Defaults to `30`. `0` disables the timeout.                                                                                                                                                                                          |
 | `BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD` | If `BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD=true`, then `bun --watch` does not clear the console on reload                                                                                                                                                                                                                                                                     |
 | `DO_NOT_TRACK`                           | Disable uploading crash reports to `bun.report` on crash. On macOS & Windows, crash report uploads are enabled by default. Bun sends no other telemetry, though we plan to add some. If `DO_NOT_TRACK=1`, then auto-uploading crash reports and telemetry are both [disabled](https://do-not-track.dev/).                                                                     |
 | `BUN_OPTIONS`                            | Prepends command-line arguments to any Bun execution. For example, `BUN_OPTIONS="--hot"` makes `bun run dev` behave like `bun --hot run dev`.                                                                                                                                                                                                                                 |

diff --git a/docs/runtime/http/server.mdx b/docs/runtime/http/server.mdx
@@ -741,6 +741,9 @@ interface TLSOptions {
   /** Server certificate */
   cert?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;
 
+  /** Certificate revocation lists */
+  crl?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;
+
   /** Path to DH parameters file */
   dhParamsFile?: string;
 
@@ -753,6 +756,12 @@ interface TLSOptions {
   /** Private key passphrase */
   passphrase?: string;
 
+  /** Refuse a peer whose certificate does not verify (default: true) */
+  rejectUnauthorized?: boolean;
+
+  /** Ask clients for a certificate (default: false) */
+  requestCert?: boolean;
+
   /** OpenSSL options flags */
   secureOptions?: number;
 

diff --git a/docs/runtime/http/tls.mdx b/docs/runtime/http/tls.mdx
@@ -55,6 +55,39 @@ Bun.serve({
 });
 ```
 
+### Client certificates (mTLS)
+
+A server asks clients for a certificate only when `requestCert` is `true`. `ca` on its own does not: it names the CAs that client certificates are verified against.
+
+```ts
+Bun.serve({
+  tls: {
+    key: Bun.file("./key.pem"),
+    cert: Bun.file("./cert.pem"),
+    ca: Bun.file("./client-ca.pem"), // CA that issues the client certificates
+    requestCert: true, // [!code ++]
+  },
+});
+```
+
+With `requestCert: true`, the server refuses a client that sends no certificate or one that `ca` does not verify. Set `rejectUnauthorized: false` to accept those clients too. The `NODE_TLS_REJECT_UNAUTHORIZED` environment variable does not change this for a server.
+
+### Certificate revocation lists
+
+Pass `crl` to refuse peer certificates that a CA has revoked. It takes the PEM contents of one or more CRLs, in the same value types as `ca`. On a server it applies to client certificates, so use it with `requestCert`.
+
+```ts
+Bun.serve({
+  tls: {
+    key: Bun.file("./key.pem"),
+    cert: Bun.file("./cert.pem"),
+    ca: Bun.file("./client-ca.pem"),
+    requestCert: true,
+    crl: Bun.file("./client-ca.crl.pem"), // [!code ++]
+  },
+});
+```
+
 ### Diffie-Hellman
 
 To override Diffie-Hellman parameters:
@@ -99,3 +132,5 @@ Bun.serve({
   ],
 });
 ```
+
+If two entries share a `serverName`, the later entry replaces the earlier one. This matches `tls.Server#addContext()`. A trailing dot is ignored, so `my-server1.com.` and `my-server1.com` name the same host. Names are compared case-insensitively, and a `*` stands for exactly one label on every transport: `*.my-server1.com` matches `a.my-server1.com` but not `a.b.my-server1.com`.
diff --git a/docs/runtime/redis.mdx b/docs/runtime/redis.mdx
@@ -409,6 +409,7 @@ const client = new RedisClient("redis://localhost:6379", {
   //   ca: "path/to/ca.pem",
   //   cert: "path/to/cert.pem",
   //   key: "path/to/key.pem",
+  //   serverName: "redis.example.com", // SNI and the name the certificate must match (default: the URL host)
   // }
 });
 ```

diff --git a/docs/runtime/sql.mdx b/docs/runtime/sql.mdx
@@ -588,6 +588,10 @@ Without a connection URL, Bun checks these individual parameters:
 | `PGDATABASE`         | -                            | username      | Database name                                                                  |
 | `PGSSLMODE`          | -                            | `disable`     | SSL mode (`disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`) |
 
+`PGSSLMODE` also applies next to a connection URL. A URL from a `TLS_*` variable uses at least `require`; `PGSSLMODE=verify-ca` and `PGSSLMODE=verify-full` raise that.
+
+An `sslmode` in the URL takes priority over both, and a mode in the `tls` or `ssl` option takes priority over the URL. `tls: true` and a `tls` object ask for at least `require` and never lower a stricter mode.
+
 ### SQLite Environment Variables
 
 You can configure SQLite connections with `DATABASE_URL` when it contains a SQLite-compatible URL:
@@ -926,7 +930,7 @@ const sql = new SQL({
 | SSL Mode      | Description                                                                                                          |
 | ------------- | -------------------------------------------------------------------------------------------------------------------- |
 | `disable`     | No SSL/TLS used. Connections fail if server requires SSL. Default mode if none specified.                            |
-| `prefer`      | Tries SSL first, falls back to non-SSL if SSL fails.                                                                 |
+| `prefer`      | Tries SSL first, falls back to non-SSL if the server does not support it.                                            |
 | `require`     | Requires SSL without certificate verification. Fails if SSL cannot be established.                                   |
 | `verify-ca`   | Verifies server certificate is signed by trusted CA. Fails if verification fails.                                    |
 | `verify-full` | Most secure mode. Verifies certificate and hostname match. Protects against untrusted certificates and MITM attacks. |

@@ -4767,6 +4767,11 @@ declare module "bun" {
      */
     serverName?: string;
 
+    /**
+     * Alias of {@link serverName}, the `node:tls` spelling. `serverName` wins if both are set.
+     */
+    servername?: string;
+
     /**
      * Sets `OPENSSL_RELEASE_BUFFERS` to 1.
      * Reduces overall performance but saves some memory.
@@ -4776,12 +4781,16 @@ declare module "bun" {
 
     /**
      * If set to `false`, any certificate is accepted.
-     * Default is `$NODE_TLS_REJECT_UNAUTHORIZED` environment variable, or `true` if it is not set.
+     *
+     * For a server, the default is `true`. `$NODE_TLS_REJECT_UNAUTHORIZED` does not change it.
+     * For a client, the default is the `$NODE_TLS_REJECT_UNAUTHORIZED` environment variable, or `true` if it is not set.
      */
     rejectUnauthorized?: boolean;
 
     /**
-     * If set to `true`, the server requests a client certificate.
+     * If set to `true`, the server requests a client certificate, and refuses
+     * a client without a valid one unless `rejectUnauthorized` is `false`.
+     * This option alone decides it: `ca` does not request a certificate.
      *
      * Default is `false`.
      */
@@ -4791,8 +4800,17 @@ declare module "bun" {
      * Optionally override the trusted CA certificates. Default is to trust
      * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
      * replaced when CAs are explicitly specified using this option.
+     *
+     * On a server these verify client certificates, which it requests only
+     * with `requestCert: true`.
      */
     ca?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
+    /**
+     * PEM formatted CRLs (Certificate Revocation Lists). A peer certificate
+     * listed in one of them fails verification: a client certificate when a
+     * server sets `requestCert`, or the server certificate when connecting.
+     */
+    crl?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
     /**
      *  Cert chains in PEM format. One cert chain should be provided per
      *  private key. Each cert chain should consist of the PEM formatted
@@ -4999,7 +5017,24 @@ declare module "bun" {
      * });
      * ```
      */
-    tls?: TLSOptions;
+    tls?: TLSOptions & {
+      /**
+       * The Node.js spelling of `serverName`.
+       */
+      servername?: string;
+      /**
+       * Replaces the built-in hostname check, as in `fetch()` and `tls.connect()`.
+       * Any truthy return value rejects the server, including the Promise of an
+       * `async` function.
+       * Through an HTTPS proxy it runs for the target's certificate only.
+       * With `rejectUnauthorized: false` it still runs when the certificate
+       * chain verified, but its result is not enforced.
+       * @param hostname - The name the certificate is verified against: `serverName` if set, else the URL host
+       * @param cert - The leaf certificate of the server, as in `fetch()`. Unlike in `tls.connect()`, it has no `issuerCertificate`
+       * @returns An error if the server is unauthorized, otherwise undefined
+       */
+      checkServerIdentity?: NonNullable<import("node:tls").ConnectionOptions["checkServerIdentity"]>;
+    };
   };
 
   type WebSocketOptionsHeaders = {
@@ -6814,6 +6849,9 @@ declare module "bun" {
      * It uses `SO_LINGER` with `l_onoff=1` and `l_linger=0` before calling `close(2)`.
      * Consider using {@link close close()} or {@link end end()} for graceful shutdowns.
      *
+     * In the `handshake` callback of a TLS 1.3 client, this refuses the server
+     * before the client certificate is sent.
+     *
      * @example
      * ```ts
      * socket.terminate();
@@ -6822,20 +6860,19 @@ declare module "bun" {
     terminate(): void;
 
     /**
-     * Shuts down the write-half or both halves of the connection.
-     * This allows the socket to enter a half-closed state where it can still receive data
-     * but can no longer send data (`halfClose = true`), or close both read and write
-     * (`halfClose = false`, similar to `end()` but potentially more immediate depending on OS).
+     * Shuts down one half of the connection.
+     * With no argument, sends a FIN: the socket can still receive data but can no longer send it.
+     * With `true`, stops receiving data.
      * Calls the `shutdown(2)` syscall internally.
      *
-     * @param halfClose If `true`, only shuts down the write side (allows receiving). If `false` or omitted, shuts down both read and write. Defaults to `false`.
+     * @param halfClose If `true`, shuts down the read side. If `false` or omitted, shuts down the write side. Defaults to `false`.
      * @example
      * ```ts
      * // Stop sending data, but allow receiving
-     * socket.shutdown(true);
-     *
-     * // Shutdown both reading and writing
      * socket.shutdown();
+     *
+     * // Stop receiving data
+     * socket.shutdown(true);
      * ```
      */
     shutdown(halfClose?: boolean): void;
@@ -7162,7 +7199,11 @@ declare module "bun" {
     getSession(): void;
 
     /**
-     * Sets the session of the socket.
+     * Sets the TLS session to offer for resumption.
+     *
+     * Only has an effect before the handshake starts: in `open`, before any
+     * `write()`, on a client socket that also has a `handshake` handler. A later
+     * call is ignored.
      *
      * @param session The session to set.
      */
@@ -7251,6 +7292,11 @@ declare module "bun" {
      */
     open?(socket: Socket<Data>): void | Promise<void>;
     close?(socket: Socket<Data>, error?: Error): void | Promise<void>;
+    /**
+     * Called when a handler throws, and when an established TLS session fails
+     * (a record that does not decrypt, a fatal alert from the peer). After a
+     * TLS failure the socket closes, with or without this handler.
+     */
     error?(socket: Socket<Data>, error: Error): void | Promise<void>;
     data?(socket: Socket<Data>, data: BinaryTypeList[DataBinaryType]): void | Promise<void>;
     drain?(socket: Socket<Data>): void | Promise<void>;

@@ -35,7 +35,8 @@ declare module "bun" {
     enableOfflineQueue?: boolean;
 
     /**
-     * TLS options
+     * TLS options. `serverName` sets the SNI and the name the certificate is
+     * verified against, which default to the URL host.
      */
     tls?: boolean | Bun.TLSOptions;
 

diff --git a/packages/bun-usockets/src/context.c b/packages/bun-usockets/src/context.c
@@ -308,9 +308,6 @@ struct us_socket_t *us_socket_adopt(struct us_socket_t *s, struct us_socket_grou
             us_internal_socket_group_link_connecting_socket(group, c);
         }
     }
-    if (old_group != group && new_s->ssl) {
-        us_internal_ssl_socket_left_group(new_s);
-    }
     new_s->group = group;
     new_s->kind = kind;
     new_s->timeout = 255;
@@ -359,8 +356,7 @@ static void us_internal_init_listen_socket(struct us_listen_socket_t *ls,
     ls->accept_kind = kind;
     ls->ssl_ctx = ssl_ctx;
     if (ssl_ctx) us_internal_ssl_ctx_up_ref(ssl_ctx);
-    ls->sni = NULL;
-    ls->on_server_name = NULL;
+    ls->server_names = NULL;
     ls->socket_ext_size = socket_ext_size;
     ls->deferred_accept = 0;
     ls->accept_paused = (options & LIBUS_SOCKET_OPEN_PAUSED) && !ssl_ctx;