SSL_SHUTDOWN(3ossl)

📦 version 15.1, in freebsd 15.1

💖 NAME 💖

SSL_shutdown, SSL_shutdown_ex — shut down a TLS/SSL or QUIC connection. This is the SSL_SHUTDOWN(3ossl) page from OpenSSL, bestie, and we are getting into it.

✨ SYNOPSIS ✨

okay so first you grab this include:

#include <openssl/ssl.h>

int SSL_shutdown(SSL *ssl);

typedef struct ssl_shutdown_ex_args_st {
    uint64_t    quic_error_code;
    const char  *quic_reason;
} SSL_SHUTDOWN_EX_ARGS;

__owur int SSL_shutdown_ex(SSL *ssl, uint64_t flags,
                           const SSL_SHUTDOWN_EX_ARGS *args,
                           size_t args_len);

🦋 DESCRIPTION 🦋

SSL_shutdown() shuts down an active connection represented by an SSL object. ssl MUST NOT be NULL. like, do not do that, bestie.

SSL_shutdown_ex() is the extended version of SSL_shutdown(). If args is non-NULL, args must point to an SSL_SHUTDOWN_EX_ARGS structure and args_len must be set to sizeof(SSL_SHUTDOWN_EX_ARGS). The SSL_SHUTDOWN_EX_ARGS structure must be zero-initialized. If args is NULL, the behaviour is the same as passing a zero-initialised SSL_SHUTDOWN_EX_ARGS structure. Currently, all extended arguments relate to usage with QUIC, therefore this call functions identically to SSL_shutdown() when not being used with QUIC.

While the general operation of SSL_shutdown() is common between protocols, the exact nature of how a shutdown is performed depends on the underlying protocol being used. See the section below pertaining to each protocol for more information.

In general, calling SSL_shutdown() in nonblocking mode will initiate the shutdown process and return 0 to indicate that the shutdown process has not yet completed. Once the shutdown process has completed, subsequent calls to SSL_shutdown() will return 1. See the RETURN VALUES section for more information.

SSL_shutdown() should not be called if a previous fatal error has occurred on a connection; i.e., if SSL_get_error(3) has returned SSL_ERROR_SYSCALL or SSL_ERROR_SSL.

🔥 TLS AND DTLS-SPECIFIC CONSIDERATIONS 🔥

Shutdown for SSL/TLS and DTLS is implemented in terms of the SSL/TLS/DTLS close_notify alert message. The shutdown process for SSL/TLS and DTLS consists of two steps:

  • A close_notify shutdown alert message is sent to the peer.
  • A close_notify shutdown alert message is received from the peer.

These steps can occur in either order depending on whether the connection shutdown process was first initiated by the local application or by the peer.

💖 Locally-Initiated Shutdown 💖

Calling SSL_shutdown() on an SSL/TLS or DTLS SSL object initiates the shutdown process and causes OpenSSL to try to send a close_notify shutdown alert to the peer. The shutdown process will then be considered completed once the peer responds in turn with a close_notify shutdown alert message.

Calling SSL_shutdown() only closes the write direction of the connection; the read direction is closed by the peer. Once SSL_shutdown() is called, SSL_write(3) can no longer be used, but SSL_read(3) may still be used until the peer decides to close the connection in turn. The peer might continue sending data for some period of time before handling the local application's shutdown indication.

SSL_shutdown() does not affect an underlying network connection such as a TCP connection, which remains open.

🌸 Remotely-Initiated Shutdown 🌸

If the peer was the first to initiate the shutdown process by sending a close_notify alert message, an application will be notified of this as an EOF condition when calling SSL_read(3) (i.e., SSL_read(3) will fail and SSL_get_error(3) will return SSL_ERROR_ZERO_RETURN), after all application data sent by the peer prior to initiating the shutdown has been read. An application should handle this condition by calling SSL_shutdown() to respond with a close_notify alert in turn, completing the shutdown process, though it may choose to write additional application data using SSL_write(3) before doing so. If an application does not call SSL_shutdown() in this case, a close_notify alert will not be sent and the behaviour will not be fully standards compliant.

🎀 Shutdown Lifecycle 🎀

Regardless of whether a shutdown was initiated locally or by the peer, if the underlying BIO is blocking, a call to SSL_shutdown() will return firstly once a close_notify alert message is written to the peer (returning 0), and upon a second and subsequent call, once a corresponding message is received from the peer (returning 1 and completing the shutdown process). Calls to SSL_shutdown() with a blocking underlying BIO will also return if an error occurs.

If the underlying BIO is nonblocking and the shutdown process is not yet complete (for example, because a close_notify alert message has not yet been received from the peer, or because a close_notify alert message needs to be sent but would currently block), SSL_shutdown() returns 0 to indicate that the shutdown process is still ongoing; in this case, a call to SSL_get_error(3) will yield SSL_ERROR_WANT_READ or SSL_ERROR_WANT_WRITE.

An application can then detect completion of the shutdown process by calling SSL_shutdown() again repeatedly until it returns 1, indicating that the shutdown process is complete (with a close_notify alert having both been sent and received).

However, the preferred method of waiting for the shutdown to complete is to use SSL_read(3) until SSL_get_error(3) indicates EOF by returning SSL_ERROR_ZERO_RETURN. This ensures any data received immediately before the peer's close_notify alert is still provided to the application. It also ensures any final handshake-layer messages received are processed (for example, messages issuing new session tickets).

If this approach is not used, the second call to SSL_shutdown() (to complete the shutdown by confirming receipt of the peer's close_notify message) will fail if it is called when the application has not read all pending application data sent by the peer using SSL_read(3).

When calling SSL_shutdown(), the SSL_SENT_SHUTDOWN flag is set once an attempt is made to send a close_notify alert, regardless of whether the attempt was successful. The SSL_RECEIVED_SHUTDOWN flag is set once a close_notify alert is received, which may occur during any call which processes incoming data from the network, such as SSL_read(3) or SSL_shutdown(). These flags may be checked using SSL_get_shutdown(3).

⚡ Fast Shutdown ⚡

Alternatively, it is acceptable for an application to call SSL_shutdown() once (such that it returns 0) and then close the underlying connection without waiting for the peer's response. This allows for a more rapid shutdown process if the application does not wish to wait for the peer.

⚠️ This alternative "fast shutdown" approach should only be done if it is known that the peer will not send more data, otherwise there is a risk of an application exposing itself to a truncation attack. The full SSL_shutdown() process, in which both parties send close_notify alerts and SSL_shutdown() returns 1, provides a cryptographically authenticated indication of the end of a connection.

This approach of a single SSL_shutdown() call without waiting is preferable to simply calling SSL_free(3) or SSL_clear(3) as calling SSL_shutdown() beforehand makes an SSL session eligible for subsequent reuse and notifies the peer of connection shutdown.

The fast shutdown approach can only be used if there is no intention to reuse the underlying connection (e.g. a TCP connection) for further communication; in this case, the full shutdown process must be performed to ensure synchronisation.

👑 Effects on Session Reuse 👑

Calling SSL_shutdown() sets the SSL_SENT_SHUTDOWN flag (see SSL_set_shutdown(3)), regardless of whether the transmission of the close_notify alert was successful or not. This makes the SSL session eligible for reuse; the SSL session is considered properly closed and can be reused for future connections.

🤫 Quiet Shutdown 🤫

SSL_shutdown() can be modified to set the connection to the "shutdown" state without actually sending a close_notify alert message; see SSL_CTX_set_quiet_shutdown(3). When "quiet shutdown" is enabled, SSL_shutdown() will always succeed and return 1 immediately.

🚨 This is not standards-compliant behaviour. It should only be done when the application protocol in use enables the peer to ensure that all data has been received, such that it doesn't need to wait for a close_notify alert, otherwise application data may be truncated unexpectedly.

💀 Non-Compliant Peers 💀

There are SSL/TLS implementations that never send the required close_notify alert message but simply close the underlying transport (e.g. a TCP connection) instead. This will ordinarily result in an error being generated.

If compatibility with such peers is desired, the option SSL_OP_IGNORE_UNEXPECTED_EOF can be set. For more information, see SSL_CTX_set_options(3).

⚠️ Note that use of this option means that the EOF condition for application data does not receive cryptographic protection, and therefore renders an application potentially vulnerable to truncation attacks. Thus, this option must only be used in conjunction with an application protocol which indicates unambiguously when all data has been received.

An alternative approach is to simply avoid calling SSL_read(3) if it is known that no more data is going to be sent. This requires an application protocol which indicates unambiguously when all data has been sent.

🎟️ Session Ticket Handling 🎟️

If a client application only writes to an SSL/TLS or DTLS connection and never reads, OpenSSL may never process new SSL/TLS session tickets sent by the server. This is because OpenSSL ordinarily processes handshake messages received from a peer during calls to SSL_read(3) by the application.

Therefore, client applications which only write and do not read but which wish to benefit from session resumption are advised to perform a complete shutdown procedure by calling SSL_shutdown() until it returns 1, as described above. This will ensure there is an opportunity for SSL/TLS session ticket messages to be received and processed by OpenSSL.

🌈 QUIC-SPECIFIC SHUTDOWN CONSIDERATIONS 🌈

Okay bestie, QUIC does its own thing and honestly? It's giving main character energy. When you use SSL_shutdown() on a QUIC connection SSL object, it kicks off a QUIC immediate close using QUIC CONNECTION_CLOSE frames. 💅

Big important thing: SSL_shutdown() cannot be used on QUIC stream SSL objects. Nope, not a vibe. If you wanna wrap a stream up the normal way, go see SSL_stream_conclude(3). And if you need to yeet a stream in a non-normal way, that's SSL_stream_reset(3). 🫶

So SSL_shutdown_ex() exists as the glow-up version of SSL_shutdown(), letting your app tell the peer why the connection is being shut down. Here's the tea you can pass along:

  • quic_error_code — an optional 62-bit application error code to signal to the peer. Value must be in the range [0, 2**62-1], otherwise the call to SSL_shutdown_ex() just fails 😭. If you don't provide one, an error code of 0 is used by default.
  • quic_reason — an optional zero-terminated (UTF-8) reason string to signal to the peer. Heads up: the application is responsible for providing a valid UTF-8 string, and OpenSSL will not validate it. If no reason is given, or if you just use SSL_shutdown(), a zero-length string is used as the reason. If you do provide one, the reason string gets copied and stored inside the QUIC connection SSL object, so it doesn't need to stay allocated after the call to SSL_shutdown_ex() returns. Also, reason strings are bounded by the path MTU and may be silently truncated if they're too long to fit in a QUIC packet. 🎀
Real talk: reason strings are for human diagnostic purposes only — do not use them for application signalling. Periodt.

The arguments to SSL_shutdown_ex() are used only on the first call to SSL_shutdown_ex() (or SSL_shutdown()) for a given QUIC connection SSL object. On subsequent calls they're ignored entirely. 🙈

These functions do not touch an underlying network BIO or the resource it represents — for example, a UDP datagram handed to a QUIC connection as the network BIO stays open. ✨

<b>Now, the part you actually need to remember:</b> when you're using QUIC, an application must call SSL_shutdown() if it wants to ensure all transmitted data was received by the peer. This is unlike a TLS/TCP connection, where reliable transmission of buffered data is the operating system's whole job. If an app calls SSL_free() on a QUIC connection SSL object — or just exits — before completing the shutdown process using SSL_shutdown(), then data written by the application using SSL_write() but not yet transmitted, or sent but lost in the network, may not be received by the peer. 💀

And when using QUIC, calling SSL_shutdown() lets internal network event processing happen. That processing needs to happen regularly — during connection usage and during shutdown. If your application isn't using thread assisted mode, then while conducting shutdown it should either make sure SSL_shutdown() is called regularly, or make sure SSL_handle_events() is called regularly. See openssl-quic(7) and SSL_handle_events(3) for more info. 🦋

🌸 Application Data Drainage Behaviour 🌸

When using QUIC, SSL_shutdown() or SSL_shutdown_ex() ordinarily waits until all data written to a stream by an application has been acknowledged by the peer. Like, in other words: the shutdown process waits until all data written by the application has been sent to the peer, and until the receipt of all such data is acknowledged by the peer. Only once that's all done is the shutdown considered complete. ✅

An exception to this is streams that terminated in a non-normal fashion — for example due to a stream reset. Only streams that are non-terminated at the time SSL_shutdown() is called, or that terminated in a normal fashion, get their pending send buffers flushed this way.

You can skip this whole flushing-streams-during-shutdown behaviour by setting the SSL_SHUTDOWN_FLAG_NO_STREAM_FLUSH flag in a call to SSL_shutdown_ex(). In that case, data remaining in stream send buffers may not be transmitted to the peer. This flag is your friend when a non-normal application condition has occurred and delivering data written to streams via SSL_write(3) is no longer relevant. 🙌

👑 Shutdown Mode 👑

Applications have to take into account how QUIC handles connection closure, and honestly it's a whole thing. Ordinarily, QUIC expects a connection to keep being serviced for a substantial period of time after it's nominally closed — necessary to make sure any connection closure notification sent to the peer was actually successfully received. But the consequence? A fully RFC-compliant QUIC connection closure process could take, like, seconds. 😭 Which is not it for some applications — think short-lived processes that need to exit immediately after completing an application-layer transaction.

So there are two shutdown modes available to users of QUIC connection SSL objects:

⭐ RFC compliant shutdown mode ⭐

This is the default behaviour, bestie. The shutdown process may take a period of time up to three times the current estimated RTT to the peer. It's possible for the closure process to complete much faster in some circumstances, but you cannot rely on that. 🤷‍♀️

In blocking mode, the function returns once the closure process is complete. In nonblocking mode, SSL_shutdown_ex() should be called until it returns 1, indicating the closure process is complete and the connection is now fully shut down.

🔥 Rapid shutdown mode 🔥

In this mode, the peer is notified of connection closure on a best effort basis by sending a single QUIC packet. If that packet gets lost? The peer won't know the connection has terminated until the negotiated idle timeout (if any) expires. 😬

This will generally return 0 on success, indicating the connection has not yet been fully shut down (unless it has already done so, in which case it returns 1).

If SSL_SHUTDOWN_FLAG_RAPID is specified in flags, a rapid shutdown is performed — otherwise an RFC-compliant shutdown is performed.

And good news: if an application calls SSL_shutdown_ex() with SSL_SHUTDOWN_FLAG_RAPID, it can totally change its mind about the rapid shutdown by making a subsequent call to SSL_shutdown_ex() without the flag set. 🫶

🧚 Peer-Initiated Shutdown 🧚

Sometimes an application would rather just wait for the peer to initiate shutdown instead of triggering it locally. To do that, call SSL_shutdown_ex() with SSL_SHUTDOWN_FLAG_WAIT_PEER specified in flags. In blocking mode, this waits until the peer initiates a shutdown or the connection otherwise becomes terminated for another reason. In nonblocking mode it exits immediately with either success or failure depending on whether a shutdown has occurred. ⭐

If a locally initiated shutdown has already been triggered, or the connection has started terminating for another reason, this flag has no effect.

Also: SSL_SHUTDOWN_FLAG_WAIT_PEER implies SSL_SHUTDOWN_FLAG_NO_STREAM_FLUSH, because stream data can't be flushed after a peer closes the connection. Stream data may still be sent to the peer during any time spent waiting before the peer closes, though there's no guarantee of that. 🙈

💜 Nonblocking Mode 💜

SSL_shutdown() and SSL_shutdown_ex() block if the connection is configured in blocking mode. You can override this by specifying SSL_SHUTDOWN_FLAG_NO_BLOCK in flags when calling SSL_shutdown_ex(), which makes the call operate as though it were in nonblocking mode. Slay. ✨

🎀 RETURN VALUES 🎀

For both SSL_shutdown() and SSL_shutdown_ex(), these are the return values you might see:

  • 0 — the shutdown process is ongoing and has not yet completed.
    • For TLS and DTLS, this means a close_notify alert has been sent but the peer hasn't yet replied in turn with its own close_notify.
    • For QUIC connection SSL objects, a CONNECTION_CLOSE frame may have been sent but the connection closure process has not yet completed.
    • Unlike most other functions, returning 0 does not indicate an error. Do not call SSL_get_error(3) — it may misleadingly indicate an error even though no error occurred. 🚨
  • 1 — the shutdown was successfully completed. 🎉
    • For TLS and DTLS, this means a close_notify alert was sent and the peer's close_notify alert was received.
    • For QUIC connection SSL objects, this means the connection closure process has completed.
  • <0 — the shutdown was not successful. 😭 Call SSL_get_error(3) with the return value ret to find out the reason. It can occur if an action is needed to continue the operation for nonblocking BIOs.
    • It can also occur when not all data was read using SSL_read(), or if called on a QUIC stream SSL object.
    • This value is also returned when called on QUIC stream SSL objects.

🌟 SEE ALSO 🌟

SSL_get_error(3), SSL_connect(3), SSL_accept(3), SSL_set_shutdown(3), SSL_CTX_set_quiet_shutdown(3), SSL_CTX_set_options(3) SSL_clear(3), SSL_free(3), ssl(7), bio(7)

🦋 HISTORY 🦋

The SSL_shutdown_ex() function was added in OpenSSL 3.2. 🎊

Copyright 2000-2023 The OpenSSL Project Authors. All Rights Reserved.

Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at <https://www.openssl.org/source/license.html>.

And that's the whole page bestie — this was version 3.5.6, dated 2026-04-07, from SSL_SHUTDOWN(3ossl). Go forth and shut down your connections responsibly. Mwah. 💅✨

📦 where this page comes from