An SSLContext is used to set various options regarding certificates, algorithms, verification, session caching, etc. The SSLContext is used to create an SSLSocket.

All attributes must be set before creating an SSLSocket as the SSLContext will be frozen afterward.


No documentation available
No documentation available
No documentation available
No documentation available

The list of available SSL/TLS methods. This constant is only provided for backwards compatibility.

No documentation available

Both client and server sessions are added to the session cache

Client sessions are added to the session cache

Normally the session cache is checked for expired sessions every 255 connections. Since this may lead to a delay that cannot be controlled, the automatic flushing may be disabled and flush_sessions can be called explicitly.

Always perform external lookups of sessions even if they are in the internal cache.

This flag has no effect on clients

Never automatically store sessions in the internal store.

No session caching for client or server

Server sessions are added to the session cache

Class Methods

Creates a new SSL context.

If an argument is given, ssl_version= is called with the value. Note that this form is deprecated. New applications should use min_version= and max_version= as necessary.

Instance Methods

Adds a certificate to the context. pkey must be a corresponding private key with certificate.

Multiple certificates with different public key type can be added by repeated calls of this method, and OpenSSL will choose the most appropriate certificate during the handshake.

cert=, key=, and extra_chain_cert= are old accessor methods for setting certificate and internally call this method.



A certificate. An instance of OpenSSL::X509::Certificate.


The private key for certificate. An instance of OpenSSL::PKey::PKey.


Optional. An array of OpenSSL::X509::Certificate. When sending a certificate chain, the certificates specified by this are sent following certificate, in the order in the array.


rsa_cert =
rsa_pkey =
ca_intermediate_cert =
ctx.add_certificate(rsa_cert, rsa_pkey, [ca_intermediate_cert])

ecdsa_cert = ...
ecdsa_pkey = ...
another_ca_cert = ...
ctx.add_certificate(ecdsa_cert, ecdsa_pkey, [another_ca_cert])


OpenSSL before the version 1.0.2 could handle only one extra chain across all key types. Calling this method discards the chain set previously.

The list of cipher suites configured for this context.

Sets the list of available cipher suites for this context. Note in a server context some ciphers require the appropriate certificates. For example, an RSA cipher suite can only be chosen when an RSA certificate is available.

Sets the list of “supported elliptic curves” for this context.

For a TLS client, the list is directly used in the Supported Elliptic Curves Extension. For a server, the list is used by OpenSSL to determine the set of shared curves. OpenSSL will pick the most appropriate one from it.

Note that this works differently with old OpenSSL (<= 1.0.1). Only one curve can be set, and this has no effect for TLS clients.


ctx1 =
ctx1.ecdh_curves = "X25519:P-256:P-224"
svr =, ctx1) { svr.accept }

ctx2 =
ctx2.ecdh_curves = "P-256"
cli =, ctx2)

# => "prime256v1" (is an alias for NIST P-256)

Activate TLS_FALLBACK_SCSV for this context. See RFC 7507.

Removes sessions in the internal cache that have expired at time.

An alias for setup

Sets the upper bound of the supported SSL/TLS protocol version. See min_version= for the possible values.

Sets the lower bound on the supported SSL/TLS protocol version. The version may be specified by an integer constant named OpenSSL::SSL::*_VERSION, a Symbol, or nil which means “any version”.

Be careful that you don't overwrite OpenSSL::SSL::OP_NO_{SSL,TLS}v* options by options= once you have called min_version= or max_version=.


ctx =
ctx.min_version = OpenSSL::SSL::TLS1_1_VERSION
ctx.max_version = OpenSSL::SSL::TLS1_2_VERSION

sock =, ctx)
sock.connect # Initiates a connection using either TLS 1.1 or TLS 1.2

Gets various OpenSSL options.

Sets various OpenSSL options.

Returns the security level for the context.

See also OpenSSL::SSL::SSLContext#security_level=.

Sets the security level for the context. OpenSSL limits parameters according to the level. The “parameters” include: ciphersuites, curves, key sizes, certificate signature algorithms, protocol version and so on. For example, level 1 rejects parameters offering below 80 bits of security, such as ciphersuites using MD5 for the MAC or RSA keys shorter than 1024 bits.

Note that attempts to set such parameters with insufficient security are also blocked. You need to lower the level first.

This feature is not supported in OpenSSL < 1.1.0, and setting the level to other than 0 will raise NotImplementedError. Level 0 means everything is permitted, the same behavior as previous versions of OpenSSL.

See the manpage of SSL_CTX_set_security_level(3) for details.

Adds session to the session cache.

The current session cache mode.

Sets the SSL session cache mode. Bitwise-or together the desired SESSION_CACHE_* constants to set. See SSL_CTX_set_session_cache_mode(3) for details.

Returns the current session cache size. Zero is used to represent an unlimited cache size.

Sets the session cache size. Returns the previously valid session cache size. Zero is used to represent an unlimited session cache size.

Returns a Hash containing the following keys:


Number of started SSL/TLS handshakes in server mode


Number of established SSL/TLS sessions in server mode


Number of start renegotiations in server mode


Number of sessions that were removed due to cache overflow


Number of successfully reused connections


Number of sessions proposed by clients that were not found in the cache


Number of sessions in the internal session cache


Number of sessions retrieved from the external cache in server mode


Number of started SSL/TLS handshakes in client mode


Number of established SSL/TLS sessions in client mode


Number of start renegotiations in client mode


Number of sessions proposed by clients that were found in the cache but had expired due to timeouts

Removes session from the session cache.

Sets the minimum and maximum supported protocol versions. See min_version= and max_version=.

Sets saner defaults optimized for the use with HTTP-like protocols.

If a Hash params is given, the parameters are overridden with it. The keys in params must be assignment methods on SSLContext.

If the verify_mode is not VERIFY_NONE and ca_file, ca_path and cert_store are not set then the system default certificate store is used.

This method is called automatically when a new SSLSocket is created. However, it is not thread-safe and must be called before creating SSLSocket objects in a multi-threaded program.

Sets the SSL/TLS protocol version for the context. This forces connections to use only the specified protocol version. This is deprecated and only provided for backwards compatibility. Use min_version= and max_version= instead.


As the name hints, this used to call the SSL_CTX_set_ssl_version() function which sets the SSL method used for connections created from the context. As of Ruby/OpenSSL 2.1, this accessor method is implemented to call min_version= and max_version= instead.