diff --git a/tornado/iostream.py b/tornado/iostream.py
index 53e81fff3..cb1d61e55 100644
--- a/tornado/iostream.py
+++ b/tornado/iostream.py
@@ -624,7 +624,10 @@ def _signal_closed(self) -> None:
                     self._ssl_connect_future.set_exception(self.error)
                 else:
                     self._ssl_connect_future.set_exception(StreamClosedError())
-            self._ssl_connect_future.exception()
+            try:
+                self._ssl_connect_future.exception()
+            except asyncio.CancelledError:
+                pass
             self._ssl_connect_future = None
         if self._close_callback is not None:
             cb = self._close_callback
@@ -1256,6 +1259,12 @@ def start_tls(
         ssl_stream._ssl_connect_future = future
         ssl_stream.max_buffer_size = self.max_buffer_size
         ssl_stream.read_chunk_size = self.read_chunk_size
+
+        def _on_cancel(fut: Future[SSLIOStream]) -> None:
+            if fut.cancelled():
+                ssl_stream.close()
+
+        future.add_done_callback(_on_cancel)  # type: ignore[arg-type]
         return future
 
     def _handle_connect(self) -> None:
diff --git a/tornado/tcpclient.py b/tornado/tcpclient.py
index 04a0c84f9..c418a9623 100644
--- a/tornado/tcpclient.py
+++ b/tornado/tcpclient.py
@@ -272,17 +272,17 @@ async def connect(
         # information here and re-use it on subsequent connections to
         # the same host. (http://tools.ietf.org/html/rfc6555#section-4.2)
         if ssl_options is not None:
+            tls_future = stream.start_tls(
+                False, ssl_options=ssl_options, server_hostname=host
+            )
             if timeout is not None:
-                stream = await gen.with_timeout(
-                    timeout,
-                    stream.start_tls(
-                        False, ssl_options=ssl_options, server_hostname=host
-                    ),
-                )
+                try:
+                    stream = await gen.with_timeout(timeout, tls_future)
+                except TimeoutError:
+                    tls_future.cancel()
+                    raise
             else:
-                stream = await stream.start_tls(
-                    False, ssl_options=ssl_options, server_hostname=host
-                )
+                stream = await tls_future
         return stream
 
     def _create_stream(
diff --git a/tornado/test/tcpclient_test.py b/tornado/test/tcpclient_test.py
index ffe65d322..6da411d06 100644
--- a/tornado/test/tcpclient_test.py
+++ b/tornado/test/tcpclient_test.py
@@ -19,6 +19,7 @@
 from contextlib import closing
 
 from tornado.concurrent import Future
+from tornado import gen
 from tornado.gen import TimeoutError
 from tornado.iostream import IOStream
 from tornado.netutil import Resolver, bind_sockets
@@ -26,6 +27,7 @@
 from tornado.tcpclient import TCPClient, _Connector
 from tornado.tcpserver import TCPServer
 from tornado.test.util import refusing_port, skipIfNoIPv6, skipIfNonUnix
+import threading
 from tornado.testing import AsyncTestCase, gen_test
 
 # Fake address families for testing.  Used in place of AF_INET
@@ -428,3 +430,84 @@ def test_two_family_timeout_after_connect_timeout(self):
         self.assertEqual(len(conn.streams), 1)
         self.assert_connector_streams_closed(conn)
         self.assertRaises(TimeoutError, future.result)
+
+
+class TCPClientSSLTest(AsyncTestCase):
+    """Tests for TCPClient SSL/TLS connect behavior."""
+
+    def setUp(self):
+        super().setUp()
+        self.server_sock = None
+
+    def tearDown(self):
+        if self.server_sock is not None:
+            try:
+                self.server_sock.close()
+            except OSError:
+                pass
+        super().tearDown()
+
+    @gen_test
+    def test_tls_handshake_timeout_closes_stream(self):
+        """When a TLS handshake times out, the SSLIOStream must be closed to
+        prevent socket file descriptor leaks (GitHub issue #3615).
+
+        This test verifies that after a timeout during the TLS handshake,
+        the underlying socket is properly closed (no fd leak).
+        """
+        import ssl as _ssl
+        import asyncio
+
+        # Set up a raw TCP server that accepts but never completes TLS.
+        self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.server_sock.bind(("127.0.0.1", 0))
+        port = self.server_sock.getsockname()[1]
+        self.server_sock.listen(1)
+        self.server_sock.settimeout(2)
+
+        accepted_socket = [None]
+
+        def accept_in_background():
+            try:
+                conn, _ = self.server_sock.accept()
+                accepted_socket[0] = conn
+                # Hold connection open without completing TLS handshake.
+                _ssl.socket.setdefaulttimeout(5)
+                time.sleep(5)
+            except Exception:
+                pass
+
+        thread = threading.Thread(target=accept_in_background, daemon=True)
+        thread.start()
+
+        # Use a very short timeout to trigger TLS handshake timeout quickly.
+        with self.assertRaises(TimeoutError):
+            yield TCPClient().connect(
+                "127.0.0.1",
+                port,
+                ssl_options=dict(cert_reqs=_ssl.CERT_NONE),
+                timeout=0.05,
+            )
+
+        thread.join(timeout=2)
+
+        # Give the IOLoop a chance to process the close callback.
+        yield gen.moment
+
+        # The key assertion: we don't care about data already in flight,
+        # but the stream must be closed (no fd leak). We verify this
+        # indirectly: if the stream wasn't closed, reading from the server
+        # side would eventually get more TLS data or hang. If it was closed,
+        # we get either empty bytes (FIN) or a connection reset error.
+        if accepted_socket[0] is not None:
+            # Drain any data already sent before the close (e.g., ClientHello).
+            accepted_socket[0].settimeout(0.5)
+            try:
+                while True:
+                    chunk = accepted_socket[0].recv(4096)
+                    if not chunk:
+                        break  # FIN received — stream was closed ✅
+            except (ConnectionResetError, BrokenPipeError, OSError):
+                pass  # Connection reset — stream was closed ✅
+