Class: OpenSSL::SSL::SSLContext (Ruby 2.3.2)
Description: Class : OpenSSL::SSL::SSLContext - Ruby 2.3.2

- Home
- Core 2.3.2
- Std-lib 2.3.2
- Downloads

Support for the Ruby 2.3 series has ended. See here for reference.

### Home Classes Methods

### In Files

- openssl/lib/openssl/ssl.rb
- openssl/ossl_ssl.c

### Parent

Object

### Namespace

- MODULE OpenSSL::SSL::SSLContext::ExtConfig

### Methods

- ::new
- #ciphers
- #ciphers=
- #flush_sessions
- #options
- #options=
- #session_add
- #session_cache_mode
- #session_cache_mode=
- #session_cache_size
- #session_cache_size=
- #session_cache_stats
- #session_remove
- #set_params
- #setup
- #ssl_version=

### Class/Module Index

Quicksearch

- Integer
- OpenSSL::ASN1
- OpenSSL::ASN1::ASN1Data
- OpenSSL::ASN1::ASN1Error
- OpenSSL::ASN1::Constructive
- OpenSSL::ASN1::ObjectId
- OpenSSL::ASN1::Primitive
- OpenSSL::BN
- OpenSSL::BNError
- OpenSSL::Buffering
- OpenSSL::Cipher
- OpenSSL::Cipher::Cipher
- OpenSSL::Cipher::CipherError
- OpenSSL::Config
- OpenSSL::ConfigError
- OpenSSL::Digest
- OpenSSL::Digest::DigestError
- OpenSSL::Engine
- OpenSSL::Engine::EngineError
- OpenSSL::ExtConfig
- OpenSSL::HMAC
- OpenSSL::HMACError
- OpenSSL::Netscape
- OpenSSL::Netscape::SPKI
- OpenSSL::Netscape::SPKIError
- OpenSSL::OCSP
- OpenSSL::OCSP::BasicResponse
- OpenSSL::OCSP::CertificateId
- OpenSSL::OCSP::OCSPError
- OpenSSL::OCSP::Request
- OpenSSL::OCSP::Response
- OpenSSL::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- OpenSSL::PKCS5::PKCS5Error
- OpenSSL::PKCS7
- OpenSSL::PKCS7::PKCS7Error
- OpenSSL::PKCS7::RecipientInfo
- OpenSSL::PKCS7::SignerInfo
- OpenSSL::PKey
- OpenSSL::PKey::DH
- OpenSSL::PKey::DHError
- OpenSSL::PKey::DSA
- OpenSSL::PKey::DSAError
- OpenSSL::PKey::EC
- OpenSSL::PKey::EC::Group
- OpenSSL::PKey::EC::Group::Error
- OpenSSL::PKey::EC::Point
- OpenSSL::PKey::EC::Point::Error
- OpenSSL::PKey::ECError
- OpenSSL::PKey::PKey
- OpenSSL::PKey::PKeyError
- OpenSSL::PKey::RSA
- OpenSSL::PKey::RSAError
- OpenSSL::Random
- OpenSSL::Random::RandomError
- OpenSSL::SSL
- OpenSSL::SSL::SSLContext
- OpenSSL::SSL::SSLContext::ExtConfig
- OpenSSL::SSL::SSLError
- OpenSSL::SSL::SSLErrorWaitReadable
- OpenSSL::SSL::SSLErrorWaitWritable
- OpenSSL::SSL::SSLServer
- OpenSSL::SSL::SSLSocket
- OpenSSL::SSL::SSLSocket::ExtConfig
- OpenSSL::SSL::Session
- OpenSSL::SSL::Session::SessionError
- OpenSSL::SSL::SocketForwarder
- OpenSSL::X509
- OpenSSL::X509::Attribute
- OpenSSL::X509::AttributeError
- OpenSSL::X509::CRL
- OpenSSL::X509::CRLError
- OpenSSL::X509::Certificate
- OpenSSL::X509::CertificateError
- OpenSSL::X509::Extension
- OpenSSL::X509::ExtensionError
- OpenSSL::X509::ExtensionFactory
- OpenSSL::X509::Name
- OpenSSL::X509::Name::RFC2253DN
- OpenSSL::X509::NameError
- OpenSSL::X509::Request
- OpenSSL::X509::RequestError
- OpenSSL::X509::Revoked
- OpenSSL::X509::RevokedError
- OpenSSL::X509::Store
- OpenSSL::X509::StoreContext
- OpenSSL::X509::StoreError
- unknown

No matching classes.

# OpenSSL::SSL::SSLContext

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.

The following attributes are available but don't show up in rdoc:

- ssl_version, cert, key, #client_ca, #ca_file, #ca_path, timeout,

- #verify_mode, #verify_depth #client_cert_cb, #tmp_dh_callback,

- #session_id_context, session_add_cb, #session_new_cb, #session_remove_cb

### Constants

DEFAULT_CERT_STORE
DEFAULT_PARAMS
INIT_VARS
METHODS

  The list of available SSL/TLS methods

SESSION_CACHE_BOTH

  Both client and server sessions are added to the session cache

SESSION_CACHE_CLIENT

  Client sessions are added to the session cache

SESSION_CACHE_NO_AUTO_CLEAR

  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.

SESSION_CACHE_NO_INTERNAL

  Enables both SESSION_CACHE_NO_INTERNAL_LOOKUP and SESSION_CACHE_NO_INTERNAL_STORE.

SESSION_CACHE_NO_INTERNAL_LOOKUP

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

  This flag has no effect on clients

SESSION_CACHE_NO_INTERNAL_STORE

  Never automatically store sessions in the internal store.

SESSION_CACHE_OFF

  No session caching for client or server

SESSION_CACHE_SERVER

  Server sessions are added to the session cache

### Attributes

alpn_protocols[RW]

An Enumerable of Strings. Each String represents a protocol to be advertised as the list of supported protocols for Application-Layer Protocol Negotiation. Supported in OpenSSL 1.0.1 and higher. Has no effect on the client side. If not set explicitly, the NPN extension will not be sent by the server in the handshake.

### Example¶ ↑

    ctx.alpn_protocols = ["http/1.1", "spdy/2", "h2"]

alpn_select_cb[RW]

A callback invoked on the server side when the server needs to select a protocol from the list sent by the client. Supported in OpenSSL 1.0.2 and higher. The server MUST select a protocol of those advertised by the client. If none is acceptable, raising an error in the callback will cause the handshake to fail. Not setting this callback explicitly means not supporting the ALPN extension on the client - any protocols advertised by the server will be ignored.

### Example¶ ↑

    ctx.alpn_select_cb = lambda do |protocols|
      #inspect the protocols and select one
      protocols.first
    end

ca_file[RW]

The path to a file containing a PEM-format CA certificate

ca_path[RW]

The path to a directory containing CA certificates in PEM format.

Files are looked up by subject's X509 name's hash value.

cert[RW]

Context certificate

cert_store[RW]

An OpenSSL::X509::Store used for certificate verification

client_ca[RW]

A certificate or Array of certificates that will be sent to the client.

client_cert_cb[RW]

A callback invoked when a client certificate is requested by a server and no certificate has been set.

The callback is invoked with a Session and must return an Array containing an OpenSSL::X509::Certificate and an OpenSSL::PKey. If any other value is returned the handshake is suspended.

extra_chain_cert[RW]

An Array of extra X509 certificates to be added to the certificate chain.

key[RW]

Context private key

npn_protocols[RW]

An Enumerable of Strings. Each String represents a protocol to be advertised as the list of supported protocols for Next Protocol Negotiation. Supported in OpenSSL 1.0.1 and higher. Has no effect on the client side. If not set explicitly, the NPN extension will not be sent by the server in the handshake.

### Example¶ ↑

    ctx.npn_protocols = ["http/1.1", "spdy/2"]

npn_select_cb[RW]

A callback invoked on the client side when the client needs to select a protocol from the list sent by the server. Supported in OpenSSL 1.0.1 and higher. The client MUST select a protocol of those advertised by the server. If none is acceptable, raising an error in the callback will cause the handshake to fail. Not setting this callback explicitly means not supporting the NPN extension on the client - any protocols advertised by the server will be ignored.

### Example¶ ↑

    ctx.npn_select_cb = lambda do |protocols|
      #inspect the protocols and select one
      protocols.first
    end

renegotiation_cb[RW]

A callback invoked whenever a new handshake is initiated. May be used to disable renegotiation entirely.

The callback is invoked with the active SSLSocket. The callback's return value is irrelevant, normal return indicates “approval” of the renegotiation and will continue the process. To forbid renegotiation and to cancel the process, an Error may be raised within the callback.

### Disable client renegotiation¶ ↑

When running a server, it is often desirable to disable client renegotiation entirely. You may use a callback as follows to implement this feature:

    num_handshakes = 0
    ctx.renegotiation_cb = lambda do |ssl|
      num_handshakes += 1
      raise RuntimeError.new("Client renegotiation disabled") if num_handshakes > 1
    end

session_get_cb[RW]

A callback invoked on a server when a session is proposed by the client but the session could not be found in the server's internal cache.

The callback is invoked with the SSLSocket and session id. The callback may return a Session from an external cache.

session_id_context[RW]

Sets the context in which a session can be reused. This allows sessions for multiple applications to be distinguished, for example, by name.

session_new_cb[RW]

A callback invoked when a new session was negotiated.

The callback is invoked with an SSLSocket. If false is returned the session will be removed from the internal cache.

session_remove_cb[RW]

A callback invoked when a session is removed from the internal cache.

The callback is invoked with an SSLContext and a Session.

ssl_timeout[RW]

Maximum session lifetime.

timeout[RW]

Maximum session lifetime.

tmp_dh_callback[RW]

A callback invoked when DH parameters are required.

The callback is invoked with the Session for the key exchange, an flag indicating the use of an export cipher and the keylength required.

The callback must return an OpenSSL::PKey::DH instance of the correct key length.

tmp_ecdh_callback[RW]

A callback invoked when ECDH parameters are required.

The callback is invoked with the Session for the key exchange, an flag indicating the use of an export cipher and the keylength required.

The callback must return an OpenSSL::PKey::EC instance of the correct key length.

verify_callback[RW]

A callback for additional certificate verification. The callback is invoked for each certificate in the chain.

The callback is invoked with two values. `preverify_ok` indicates indicates if the verification was passed (true) or not (false). `store_context` is an OpenSSL::X509::StoreContext containing the context used for certificate verification.

If the callback returns false verification is stopped.

verify_depth[RW]

Number of CA certificates to walk when verifying a certificate chain.

verify_mode[RW]

Session verification mode.

Valid modes are VERIFY_NONE, VERIFY_PEER, VERIFY_CLIENT_ONCE, VERIFY_FAIL_IF_NO_PEER_CERT and defined on OpenSSL::SSL

### Public Class Methods

new => ctx click to toggle source
new(:TLSv1) => ctx
new("SSLv23_client") => ctx

You can get a list of valid methods with OpenSSL::SSL::SSLContext::METHODS

                   # File openssl/lib/openssl/ssl.rb, line 107
    def initialize(version = nil)
      INIT_VARS.each { |v| instance_variable_set v, nil }
      self.options = self.options | OpenSSL::SSL::OP_ALL
      return unless version
      self.ssl_version = version
    end

### Public Instance Methods

ciphers => [[name, version, bits, alg_bits], ...] click to toggle source

The list of ciphers configured for this context.

                   static VALUE
    ossl_sslctx_get_ciphers(VALUE self)
    {
        SSL_CTX *ctx;
        STACK_OF(SSL_CIPHER) *ciphers;
        SSL_CIPHER *cipher;
        VALUE ary;
        int i, num;

        GetSSLCTX(self, ctx);
        if(!ctx){
            rb_warning("SSL_CTX is not initialized.");
            return Qnil;
        }
        ciphers = ctx->cipher_list;

        if (!ciphers)
            return rb_ary_new();

        num = sk_SSL_CIPHER_num(ciphers);
        ary = rb_ary_new2(num);
        for(i = 0; i < num; i++){
            cipher = sk_SSL_CIPHER_value(ciphers, i);
            rb_ary_push(ary, ossl_ssl_cipher_to_ary(cipher));
        }
        return ary;
    }

ciphers = "cipher1:cipher2:..." click to toggle source
ciphers = [name, ...]
ciphers = [[name, version, bits, alg_bits], ...]

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

See also OpenSSL::Cipher and OpenSSL::Cipher.ciphers

                   static VALUE
    ossl_sslctx_set_ciphers(VALUE self, VALUE v)
    {
        SSL_CTX *ctx;
        VALUE str, elem;
        int i;

        rb_check_frozen(self);
        if (NIL_P(v))
            return v;
        else if (RB_TYPE_P(v, T_ARRAY)) {
            str = rb_str_new(0, 0);
            for (i = 0; i < RARRAY_LEN(v); i++) {
                elem = rb_ary_entry(v, i);
                if (RB_TYPE_P(elem, T_ARRAY)) elem = rb_ary_entry(elem, 0);
                elem = rb_String(elem);
                rb_str_append(str, elem);
                if (i < RARRAY_LEN(v)-1) rb_str_cat2(str, ":");
            }
        } else {
            str = v;
            StringValue(str);
        }

        GetSSLCTX(self, ctx);
        if(!ctx){
            ossl_raise(eSSLError, "SSL_CTX is not initialized.");
            return Qnil;
        }
        if (!SSL_CTX_set_cipher_list(ctx, RSTRING_PTR(str))) {
            ossl_raise(eSSLError, "SSL_CTX_set_cipher_list");
        }

        return v;
    }

flush_sessions(time | nil) → self click to toggle source

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

                   static VALUE
    ossl_sslctx_flush_sessions(int argc, VALUE *argv, VALUE self)
    {
        VALUE arg1;
        SSL_CTX *ctx;
        time_t tm = 0;

        rb_scan_args(argc, argv, "01", &arg1);

        GetSSLCTX(self, ctx);

        if (NIL_P(arg1)) {
            tm = time(0);
        } else if (rb_obj_is_instance_of(arg1, rb_cTime)) {
            tm = NUM2LONG(rb_funcall(arg1, rb_intern("to_i"), 0));
        } else {
            ossl_raise(rb_eArgError, "arg must be Time or nil");
        }

        SSL_CTX_flush_sessions(ctx, (long)tm);

        return self;
    }

options() click to toggle source

Gets various OpenSSL options.

                   static VALUE
    ossl_sslctx_get_options(VALUE self)
    {
        SSL_CTX *ctx;
        GetSSLCTX(self, ctx);
        return LONG2NUM(SSL_CTX_get_options(ctx));
    }

options=(p1) click to toggle source

Sets various OpenSSL options.

                   static VALUE
    ossl_sslctx_set_options(VALUE self, VALUE options)
    {
        SSL_CTX *ctx;

        rb_check_frozen(self);
        GetSSLCTX(self, ctx);

        SSL_CTX_clear_options(ctx, SSL_CTX_get_options(ctx));

        if (NIL_P(options)) {
            SSL_CTX_set_options(ctx, SSL_OP_ALL);
        } else {
            SSL_CTX_set_options(ctx, NUM2LONG(options));
        }

        return self;
    }

session_add(session) → true | false click to toggle source

Adds `session` to the session cache

                   static VALUE
    ossl_sslctx_session_add(VALUE self, VALUE arg)
    {
        SSL_CTX *ctx;
        SSL_SESSION *sess;

        GetSSLCTX(self, ctx);
        SafeGetSSLSession(arg, sess);

        return SSL_CTX_add_session(ctx, sess) == 1 ? Qtrue : Qfalse;
    }

session_cache_mode → Integer click to toggle source

The current session cache mode.

                   static VALUE
    ossl_sslctx_get_session_cache_mode(VALUE self)
    {
        SSL_CTX *ctx;

        GetSSLCTX(self, ctx);

        return LONG2NUM(SSL_CTX_get_session_cache_mode(ctx));
    }

session_cache_mode=(integer) → Integer click to toggle source

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.

                   static VALUE
    ossl_sslctx_set_session_cache_mode(VALUE self, VALUE arg)
    {
        SSL_CTX *ctx;

        GetSSLCTX(self, ctx);

        SSL_CTX_set_session_cache_mode(ctx, NUM2LONG(arg));

        return arg;
    }

session_cache_size → Integer click to toggle source

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

                   static VALUE
    ossl_sslctx_get_session_cache_size(VALUE self)
    {
        SSL_CTX *ctx;

        GetSSLCTX(self, ctx);

        return LONG2NUM(SSL_CTX_sess_get_cache_size(ctx));
    }

session_cache_size=(integer) → Integer click to toggle source

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

                   static VALUE
    ossl_sslctx_set_session_cache_size(VALUE self, VALUE arg)
    {
        SSL_CTX *ctx;

        GetSSLCTX(self, ctx);

        SSL_CTX_sess_set_cache_size(ctx, NUM2LONG(arg));

        return arg;
    }

session_cache_stats → Hash click to toggle source

Returns a Hash containing the following keys:

:accept

  Number of started SSL/TLS handshakes in server mode

:accept_good

  Number of established SSL/TLS sessions in server mode

:accept_renegotiate

  Number of start renegotiations in server mode

:cache_full

  Number of sessions that were removed due to cache overflow

:cache_hits

  Number of successfully reused connections

:cache_misses

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

:cache_num

  Number of sessions in the internal session cache

:cb_hits

  Number of sessions retrieved from the external cache in server mode

:connect

  Number of started SSL/TLS handshakes in client mode

:connect_good

  Number of established SSL/TLS sessions in client mode

:connect_renegotiate

  Number of start renegotiations in client mode

:timeouts

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

                   static VALUE
    ossl_sslctx_get_session_cache_stats(VALUE self)
    {
        SSL_CTX *ctx;
        VALUE hash;

        GetSSLCTX(self, ctx);

        hash = rb_hash_new();
        rb_hash_aset(hash, ID2SYM(rb_intern("cache_num")), LONG2NUM(SSL_CTX_sess_number(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("connect")), LONG2NUM(SSL_CTX_sess_connect(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("connect_good")), LONG2NUM(SSL_CTX_sess_connect_good(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("connect_renegotiate")), LONG2NUM(SSL_CTX_sess_connect_renegotiate(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("accept")), LONG2NUM(SSL_CTX_sess_accept(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("accept_good")), LONG2NUM(SSL_CTX_sess_accept_good(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("accept_renegotiate")), LONG2NUM(SSL_CTX_sess_accept_renegotiate(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("cache_hits")), LONG2NUM(SSL_CTX_sess_hits(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("cb_hits")), LONG2NUM(SSL_CTX_sess_cb_hits(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("cache_misses")), LONG2NUM(SSL_CTX_sess_misses(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("cache_full")), LONG2NUM(SSL_CTX_sess_cache_full(ctx)));
        rb_hash_aset(hash, ID2SYM(rb_intern("timeouts")), LONG2NUM(SSL_CTX_sess_timeouts(ctx)));

        return hash;
    }

session_remove(session) → true | false click to toggle source

Removes `session` from the session cache

                   static VALUE
    ossl_sslctx_session_remove(VALUE self, VALUE arg)
    {
        SSL_CTX *ctx;
        SSL_SESSION *sess;

        GetSSLCTX(self, ctx);
        SafeGetSSLSession(arg, sess);

        return SSL_CTX_remove_session(ctx, sess) == 1 ? Qtrue : Qfalse;
    }

set_params(params={}) click to toggle source

Sets the parameters for this SSL context to the values in `params`. 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.

                   # File openssl/lib/openssl/ssl.rb, line 122
    def set_params(params={})
      params = DEFAULT_PARAMS.merge(params)
      params.each{|name, value| self.__send__("#{name}=", value) }
      if self.verify_mode != OpenSSL::SSL::VERIFY_NONE
        unless self.ca_file or self.ca_path or self.cert_store
          self.cert_store = DEFAULT_CERT_STORE
        end
      end
      return params
    end

setup => Qtrue # first time click to toggle source
setup => nil # thereafter

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.

                   static VALUE
    ossl_sslctx_setup(VALUE self)
    {
        SSL_CTX *ctx;
        X509 *cert = NULL, *client_ca = NULL;
        X509_STORE *store;
        EVP_PKEY *key = NULL;
        char *ca_path = NULL, *ca_file = NULL;
        int verify_mode;
        long i;
        VALUE val;

        if(OBJ_FROZEN(self)) return Qnil;
        GetSSLCTX(self, ctx);

    #if !defined(OPENSSL_NO_DH)
        SSL_CTX_set_tmp_dh_callback(ctx, ossl_tmp_dh_callback);
    #endif

    #if !defined(OPENSSL_NO_EC)
        if (RTEST(ossl_sslctx_get_tmp_ecdh_cb(self))){
            SSL_CTX_set_tmp_ecdh_callback(ctx, ossl_tmp_ecdh_callback);
        }
    #endif

        val = ossl_sslctx_get_cert_store(self);
        if(!NIL_P(val)){
            /*
             * WORKAROUND:
             *   X509_STORE can count references, but
             *   X509_STORE_free() doesn't care it.
             *   So we won't increment it but mark it by ex_data.
             */
            store = GetX509StorePtr(val); /* NO NEED TO DUP */
            SSL_CTX_set_cert_store(ctx, store);
            SSL_CTX_set_ex_data(ctx, ossl_ssl_ex_store_p, (void*)1);
        }

        val = ossl_sslctx_get_extra_cert(self);
        if(!NIL_P(val)){
            rb_block_call(val, rb_intern("each"), 0, 0, ossl_sslctx_add_extra_chain_cert_i, self);
        }

        /* private key may be bundled in certificate file. */
        val = ossl_sslctx_get_cert(self);
        cert = NIL_P(val) ? NULL : GetX509CertPtr(val); /* NO DUP NEEDED */
        val = ossl_sslctx_get_key(self);
        key = NIL_P(val) ? NULL : GetPKeyPtr(val); /* NO DUP NEEDED */
        if (cert && key) {
            if (!SSL_CTX_use_certificate(ctx, cert)) {
                /* Adds a ref => Safe to FREE */
                ossl_raise(eSSLError, "SSL_CTX_use_certificate");
            }
            if (!SSL_CTX_use_PrivateKey(ctx, key)) {
                /* Adds a ref => Safe to FREE */
                ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey");
            }
            if (!SSL_CTX_check_private_key(ctx)) {
                ossl_raise(eSSLError, "SSL_CTX_check_private_key");
            }
        }

        val = ossl_sslctx_get_client_ca(self);
        if(!NIL_P(val)){
            if (RB_TYPE_P(val, T_ARRAY)) {
                for(i = 0; i < RARRAY_LEN(val); i++){
                    client_ca = GetX509CertPtr(RARRAY_AREF(val, i));
                    if (!SSL_CTX_add_client_CA(ctx, client_ca)){
                        /* Copies X509_NAME => FREE it. */
                        ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
                    }
                }
            }
            else{
                client_ca = GetX509CertPtr(val); /* NO DUP NEEDED. */
                if (!SSL_CTX_add_client_CA(ctx, client_ca)){
                    /* Copies X509_NAME => FREE it. */
                    ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
                }
            }
        }

        val = ossl_sslctx_get_ca_file(self);
        ca_file = NIL_P(val) ? NULL : StringValuePtr(val);
        val = ossl_sslctx_get_ca_path(self);
        ca_path = NIL_P(val) ? NULL : StringValuePtr(val);
        if(ca_file || ca_path){
            if (!SSL_CTX_load_verify_locations(ctx, ca_file, ca_path))
                rb_warning("can't set verify locations");
        }

        val = ossl_sslctx_get_verify_mode(self);
        verify_mode = NIL_P(val) ? SSL_VERIFY_NONE : NUM2INT(val);
        SSL_CTX_set_verify(ctx, verify_mode, ossl_ssl_verify_callback);
        if (RTEST(ossl_sslctx_get_client_cert_cb(self)))
            SSL_CTX_set_client_cert_cb(ctx, ossl_client_cert_cb);

        val = ossl_sslctx_get_timeout(self);
        if(!NIL_P(val)) SSL_CTX_set_timeout(ctx, NUM2LONG(val));

        val = ossl_sslctx_get_verify_dep(self);
        if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2INT(val));

    #ifdef HAVE_SSL_CTX_SET_NEXT_PROTO_SELECT_CB
        val = rb_iv_get(self, "@npn_protocols");
        if (!NIL_P(val)) {
            rb_iv_set(self, "@_protocols", ssl_encode_npn_protocols(val));
            SSL_CTX_set_next_protos_advertised_cb(ctx, ssl_npn_advertise_cb, (void *) self);
            OSSL_Debug("SSL NPN advertise callback added");
        }
        if (RTEST(rb_iv_get(self, "@npn_select_cb"))) {
            SSL_CTX_set_next_proto_select_cb(ctx, ssl_npn_select_cb, (void *) self);
            OSSL_Debug("SSL NPN select callback added");
        }
    #endif

    #ifdef HAVE_SSL_CTX_SET_ALPN_SELECT_CB
        val = rb_iv_get(self, "@alpn_protocols");
        if (!NIL_P(val)) {
            VALUE rprotos = ssl_encode_npn_protocols(val);
            SSL_CTX_set_alpn_protos(ctx, (const unsigned char *)StringValueCStr(rprotos), RSTRING_LENINT(rprotos));
            OSSL_Debug("SSL ALPN values added");
        }
        if (RTEST(rb_iv_get(self, "@alpn_select_cb"))) {
            SSL_CTX_set_alpn_select_cb(ctx, ssl_alpn_select_cb, (void *) self);
            OSSL_Debug("SSL ALPN select callback added");
        }
    #endif

        rb_obj_freeze(self);

        val = ossl_sslctx_get_sess_id_ctx(self);
        if (!NIL_P(val)){
            StringValue(val);
            if (!SSL_CTX_set_session_id_context(ctx, (unsigned char *)RSTRING_PTR(val),
                                                RSTRING_LENINT(val))){
                ossl_raise(eSSLError, "SSL_CTX_set_session_id_context");
            }
        }

        if (RTEST(rb_iv_get(self, "@session_get_cb"))) {
            SSL_CTX_sess_set_get_cb(ctx, ossl_sslctx_session_get_cb);
            OSSL_Debug("SSL SESSION get callback added");
        }
        if (RTEST(rb_iv_get(self, "@session_new_cb"))) {
            SSL_CTX_sess_set_new_cb(ctx, ossl_sslctx_session_new_cb);
            OSSL_Debug("SSL SESSION new callback added");
        }
        if (RTEST(rb_iv_get(self, "@session_remove_cb"))) {
            SSL_CTX_sess_set_remove_cb(ctx, ossl_sslctx_session_remove_cb);
            OSSL_Debug("SSL SESSION remove callback added");
        }

    #ifdef HAVE_SSL_SET_TLSEXT_HOST_NAME
        val = rb_iv_get(self, "@servername_cb");
        if (!NIL_P(val)) {
            SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
            OSSL_Debug("SSL TLSEXT servername callback added");
        }
    #endif

        return Qtrue;
    }

ssl_version = :TLSv1 click to toggle source
ssl_version = "SSLv23_client"

You can get a list of valid versions with OpenSSL::SSL::SSLContext::METHODS

                   static VALUE
    ossl_sslctx_set_ssl_version(VALUE self, VALUE ssl_method)
    {
        SSL_METHOD *method = NULL;
        const char *s;
        VALUE m = ssl_method;
        int i;

        SSL_CTX *ctx;
        if (RB_TYPE_P(ssl_method, T_SYMBOL))
            m = rb_sym2str(ssl_method);
        s = StringValueCStr(m);
        for (i = 0; i < numberof(ossl_ssl_method_tab); i++) {
            if (strcmp(ossl_ssl_method_tab[i].name, s) == 0) {
                method = ossl_ssl_method_tab[i].func();
                break;
            }
        }
        if (!method) {
            ossl_raise(rb_eArgError, "unknown SSL method `%"PRIsVALUE"'.", m);
        }
        GetSSLCTX(self, ctx);
        if (SSL_CTX_set_ssl_version(ctx, method) != 1) {
            ossl_raise(eSSLError, "SSL_CTX_set_ssl_version");
        }

        return ssl_method;
    }