класс OpenSSL::SSL::SSLContext

Родитель:: Объект

Контекст SSLContext используется для настройки различных параметров сертификатов, алгоритмов, проверки, кэширования сессий и т. д. Контекст SSLContext используется для создания объекта SSLSocket.

Все атрибуты должны быть установлены до создания объекта SSLSocket, так как контекст SSLContext будет заморожен после этого.

Следующие атрибуты доступны, но не отображаются в 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

Константы

DEFAULT_CERT_STORE

DEFAULT_PARAMS

INIT_VARS

METHODS

Список доступных методов SSL/TLS

SESSION_CACHE_BOTH

В кэш сессий добавляются сессии как клиента, так и сервера.

SESSION_CACHE_CLIENT

В кэш сессий добавляются сессии клиента.

SESSION_CACHE_NO_AUTO_CLEAR

Обычно кэш сессий проверяется на наличие истекших сессий каждые 255 подключений. Поскольку это может привести к задержке, которую нельзя контролировать, автоматическое очищение может быть отключено, и метод flush_sessions может быть вызван явно.

SESSION_CACHE_NO_INTERNAL

Включает как SESSION_CACHE_NO_INTERNAL_LOOKUP, так и SESSION_CACHE_NO_INTERNAL_STORE.

SESSION_CACHE_NO_INTERNAL_LOOKUP

Всегда выполнять внешний поиск сессий, даже если они находятся во внутреннем кэше.

Этот флаг не имеет эффекта для клиентов.

SESSION_CACHE_NO_INTERNAL_STORE

Никогда не хранить сессии автоматически во внутреннем хранилище.

SESSION_CACHE_OFF

Отключение кэширования сессий для клиента и сервера.

SESSION_CACHE_SERVER

В кэш сессий добавляются сессии сервера.

Атрибуты

alpn_protocols[RW]

Перечислитель (Enumerable) строк. Каждая строка представляет протокол, который будет рекламироваться как список поддерживаемых протоколов для переговор Application-Layer Protocol Negotiation. Поддерживается в OpenSSL 1.0.1 и выше. Не имеет эффекта на стороне клиента. Если не задано явно, расширение NPN не будет отправлено сервером во время рукопожатия.

Пример

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

alpn_select_cb[RW]

Обратный вызов, вызываемый на стороне сервера, когда серверу нужно выбрать протокол из списка, отправленного клиентом. Поддерживается в OpenSSL 1.0.2 и выше. Сервер ОБЯЗАН выбрать протокол из тех, которые рекламируются клиентом. Если ни один не приемлем, возникновение ошибки в обратном вызове приведет к сбою рукопожатия. Если обратный вызов не задан явно, это означает, что расширение ALPN не поддерживается на стороне клиента — любые рекламируемые протоколы сервера будут проигнорированы.

Пример

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

ca_file[RW]

Путь к файлу, содержащему сертификат CA в формате PEM.

ca_path[RW]

Путь к каталогу, содержащему сертификаты CA в формате PEM.

Файлы находятся по хэшу имени субъекта X509.

cert[RW]

Сертификат контекста.

cert_store[RW]

Объект OpenSSL::X509::Store, используемый для проверки сертификатов.

client_ca[RW]

Сертификат или массив сертификатов, которые будут отправлены клиенту.

client_cert_cb[RW]

Обратный вызов, вызываемый, когда клиент запрашивает сертификат клиента, и сертификат не был задан.

Обратный вызов вызывается с Session и должен возвращать массив, содержащий OpenSSL::X509::Certificate и OpenSSL::PKey. Если возвращается любое другое значение, рукопожатие приостанавливается.

extra_chain_cert[RW]

Массив дополнительных сертификатов X509 для добавления в цепочку сертификатов.

key[RW]

Закрытый ключ контекста.

npn_protocols[RW]

Перечислитель (Enumerable) строк. Каждая строка представляет протокол, который будет рекламироваться как список поддерживаемых протоколов для переговор Next Protocol Negotiation. Поддерживается в OpenSSL 1.0.1 и выше. Не имеет эффекта на стороне клиента. Если не задано явно, расширение NPN не будет отправлено сервером во время рукопожатия.

Пример

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

npn_select_cb[RW]

Обратный вызов, вызываемый на стороне клиента, когда клиенту нужно выбрать протокол из списка, отправленного сервером. Поддерживается в OpenSSL 1.0.1 и выше. Клиент ОБЯЗАН выбрать протокол из тех, которые рекламируются сервером. Если ни один не приемлем, возникновение ошибки в обратном вызове приведет к сбою рукопожатия. Если обратный вызов не задан явно, это означает, что расширение NPN не поддерживается на стороне клиента — любые рекламируемые протоколы сервера будут проигнорированы.

Пример

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

renegotiation_cb[RW]

Обратный вызов, вызываемый всякий раз, когда инициируется новое рукопожатие. Может использоваться для полного отключения повторных переговоров.

Обратный вызов вызывается с активным SSLSocket. Возвращаемое значение обратного вызова не имеет значения, нормальное возвращение указывает на «утверждение» повторных переговоров и продолжит процесс. Для запрета повторных переговоров и отмены процесса может быть вызвано исключение в обратном вызове.

Отключить повторные переговоры клиента

При работе с сервером часто желательно полностью отключить повторные переговоры клиента. Вы можете использовать обратный вызов следующим образом, чтобы реализовать эту функцию:

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]

Обратный вызов, вызываемый на сервере, когда клиент предлагает сеанс, но сеанс не найден в кэше сервера.

Обратный вызов вызывается с SSLSocket и идентификатором сеанса. Обратный вызов может вернуть Session из внешнего кэша.

session_id_context[RW]

Устанавливает контекст, в котором сеанс может быть повторно использован. Это позволяет различать сеансы для нескольких приложений, например, по имени.

session_new_cb[RW]

Обратный вызов, вызываемый при согласовании нового сеанса.

Обратный вызов вызывается с SSLSocket. Если возвращается false, сеанс будет удален из внутреннего кэша.

session_remove_cb[RW]

Обратный вызов, вызываемый при удалении сеанса из внутреннего кэша.

Обратный вызов вызывается с SSLContext и Session.

ssl_timeout[RW]

Максимальная продолжительность жизни сеанса.

timeout[RW]

Максимальная продолжительность жизни сеанса.

tmp_dh_callback[RW]

Обратный вызов, вызываемый, когда требуются параметры DH.

Обратный вызов вызывается с Session для обмена ключами, флагом, указывающим на использование экспортного шифра, и требуемой длиной ключа.

Обратный вызов должен вернуть экземпляр OpenSSL::PKey::DH правильной длины ключа.

tmp_ecdh_callback[RW]

Обратный вызов, вызываемый, когда требуются параметры ECDH.

Обратный вызов должен вернуть экземпляр OpenSSL::PKey::EC правильной длины ключа.

verify_callback[RW]

Обратный вызов для дополнительной проверки сертификата. Обратный вызов вызывается для каждого сертификата в цепочке.

Обратный вызов вызывается со значениями. preverify_ok указывает, прошла ли проверка (true) или нет (false). store_context — OpenSSL::X509::StoreContext, содержащий контекст, используемый для проверки сертификата.

Если обратный вызов возвращает false, проверка останавливается.

verify_depth[RW]

Количество сертификатов CA, которое необходимо пройти при проверке цепочки сертификатов.

verify_mode[RW]

Режим проверки сеанса.

Допустимые режимы: VERIFY_NONE, VERIFY_PEER, VERIFY_CLIENT_ONCE, VERIFY_FAIL_IF_NO_PEER_CERT и определены в OpenSSL::SSL.

Методы публичного класса

new → ctx Показать исходный код

new(:TLSv1) → ctx

new("SSLv23_client") → ctx

# File ext/openssl/lib/openssl/ssl.rb, line 108
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

Вы можете получить список допустимых методов с помощью OpenSSL::SSL::SSLContext::METHODS.

Методы публичного экземпляра

ciphers → [[name, version, bits, alg_bits], ...] Показать исходный код

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:..." Показать исходный код

ciphers = [name, ...]

ciphers = [[name, version, bits, alg_bits], ...]

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;
}

Устанавливает список доступных шифров для этого контекста. Обратите внимание, что в контексте сервера некоторые шифры требуют соответствующие сертификаты. Например, шифр RSA можно выбрать только в том случае, если доступен сертификат RSA.

См. также OpenSSL::Cipher и OpenSSL::Cipher.ciphers

flush_sessions(time | nil) → self Показать исходный код

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;
}

Удаляет сеансы в кэше, которые истекли по состоянию на time.

options() Показать исходный код

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

Получает различные параметры OpenSSL.

options=(p1) Показать исходный код

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;
}

Устанавливает различные параметры OpenSSL.

session_add(session) → true | false Показать исходный код

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 в кэш сеансов.

session_cache_mode → Integer Показать исходный код

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 Показать исходный код

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;
}

Устанавливает режим кэширования сеансов SSL. Объедините константы SESSION_CACHE_* в битовом ИЛИ, чтобы установить необходимые значения. Для получения подробной информации см. SSL_CTX_set_session_cache_mode(3).

session_cache_size → Integer Показать исходный код

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 Показать исходный код

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 Показать исходный код

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;
}

Возвращает Hash, содержащий следующие ключи:

:accept: Количество начатых SSL/TLS рукопожатий в режиме сервера
:accept_good: Количество установленных SSL/TLS сеансов в режиме сервера
:accept_renegotiate: Количество начатых переподключений в режиме сервера
:cache_full: Количество сеансов, удалённых из-за переполнения кэша
:cache_hits: Количество успешно повторно использованных подключений
:cache_misses: Количество предложенных клиентами сеансов, которые не были найдены в кэше
:cache_num: Количество сеансов во внутреннем кэше сеансов
:cb_hits: Количество сеансов, извлечённых из внешнего кэша в режиме сервера
:connect: Количество начатых SSL/TLS рукопожатий в режиме клиента
:connect_good: Количество установленных SSL/TLS сеансов в режиме клиента
:connect_renegotiate: Количество начатых переподключений в режиме клиента
:timeouts: Количество сеансов, предложенных клиентами, которые были найдены в кэше, но истекли из-за таймаутов

session_remove(session) → true | false Показать исходный код

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;
}

Удаляет session из кэша сеансов.

set_params(params={}) Показать исходный код

# File ext/openssl/lib/openssl/ssl.rb, line 123
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

Устанавливает параметры для этого контекста SSL в значения из params. Ключи в params должны соответствовать методам присваивания в SSLContext.

Если режим #verify_mode не VERIFY_NONE и #ca_file, #ca_path и #cert_store не установлены, используется системный кэш сертификатов по умолчанию.

setup → Qtrue # первый раз Показать исходный код

setup → nil # в дальнейшем

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;
}

Этот метод вызывается автоматически при создании нового SSLSocket. Однако он не потокобезопасен и должен вызываться до создания объектов SSLSocket в многопоточной программе.

ssl_version = :TLSv1 Показать исходный код

ssl_version = "SSLv23_client"

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;
}

Вы можете получить список допустимых версий с помощью OpenSSL::SSL::SSLContext::METHODS.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.