class OpenSSL::SSL::SSLSocket

Attribute

Das SSLContext-Objekt, das in dieser Verbindung verwendet wird.

Das zugrunde liegende IO-Objekt.

Ob der zugrunde liegende Socket ebenfalls geschlossen werden soll, wenn die SSL/TLS-Verbindung beendet wird. Dies ist standardmäßig auf false gesetzt.

to_io [R]

Das zugrunde liegende IO-Objekt.

Öffentliche Klassenmethoden

new(io) → aSSLSocket

new(io, ctx) → aSSLSocket

Source

static VALUE
ossl_ssl_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE io, v_ctx;
    SSL *ssl;
    SSL_CTX *ctx;

    TypedData_Get_Struct(self, SSL, &ossl_ssl_type, ssl);
    if (ssl)
        ossl_raise(eSSLError, "SSL already initialized");

    if (rb_scan_args(argc, argv, "11", &io, &v_ctx) == 1)
        v_ctx = rb_funcall(cSSLContext, rb_intern("new"), 0);

    GetSSLCTX(v_ctx, ctx);
    rb_ivar_set(self, id_i_context, v_ctx);
    ossl_sslctx_setup(v_ctx);

    if (rb_respond_to(io, rb_intern("nonblock=")))
        rb_funcall(io, rb_intern("nonblock="), 1, Qtrue);
    Check_Type(io, T_FILE);
    rb_ivar_set(self, id_i_io, io);

    ssl = SSL_new(ctx);
    if (!ssl)
        ossl_raise(eSSLError, NULL);
    RTYPEDDATA_DATA(self) = ssl;

    SSL_set_ex_data(ssl, ossl_ssl_ex_ptr_idx, (void *)self);
    SSL_set_info_callback(ssl, ssl_info_cb);

    rb_call_super(0, NULL);

    return self;
}

Erstellt einen neuen SSL-Socket aus io, der ein echter IO-Objekt sein muss (kein IO-ähnliches Objekt, das auf read/write reagiert).

Wenn ctx angegeben ist, werden die Anfangsparameter des SSL-Sockets aus dem Kontext übernommen.

Das Modul OpenSSL::Buffering bietet zusätzliche IO-Methoden.

Diese Methode friert den SSLContext ein, wenn einer angegeben ist; die Sitzungsverwaltung ist jedoch auch in dem eingefrorenen SSLContext noch erlaubt.

open(remote_host, remote_port, local_host=nil, local_port=nil, context: nil)

Source

# File ext/openssl/lib/openssl/ssl.rb, line 465
def open(remote_host, remote_port, local_host=nil, local_port=nil, context: nil)
  sock = ::TCPSocket.open(remote_host, remote_port, local_host, local_port)
  if context.nil?
    return OpenSSL::SSL::SSLSocket.new(sock)
  else
    return OpenSSL::SSL::SSLSocket.new(sock, context)
  end
end

Erstellt eine neue Instanz von SSLSocket. remotehost_ und remoteport_ werden verwendet, um einen TCPSocket zu öffnen. Wenn localhost_ und localport_ angegeben sind, werden diese Parameter auf der lokalen Seite verwendet, um die Verbindung herzustellen. Wenn context angegeben ist, werden die Anfangsparameter des SSL-Sockets aus dem Kontext übernommen.

Beispiele

sock = OpenSSL::SSL::SSLSocket.open('localhost', 443)
sock.connect # Initiates a connection to localhost:443

mit SSLContext

ctx = OpenSSL::SSL::SSLContext.new
sock = OpenSSL::SSL::SSLSocket.open('localhost', 443, context: ctx)
sock.connect # Initiates a connection to localhost:443 with SSLContext

Öffentliche Instanzmethoden

accept → self

Source

static VALUE
ossl_ssl_accept(VALUE self)
{
    ossl_ssl_setup(self);

    return ossl_start_ssl(self, SSL_accept, "SSL_accept", Qfalse);
}

Wartet darauf, dass ein SSL/TLS-Client eine Aushandlung initiiert.

accept_nonblock([options]) → self

Source

static VALUE
ossl_ssl_accept_nonblock(int argc, VALUE *argv, VALUE self)
{
    VALUE opts;

    rb_scan_args(argc, argv, "0:", &opts);
    ossl_ssl_setup(self);

    return ossl_start_ssl(self, SSL_accept, "SSL_accept", opts);
}

Initiiert die SSL/TLS-Aushandlung als Server im Non-Blocking-Modus.

# emulates blocking accept
begin
  ssl.accept_nonblock
rescue IO::WaitReadable
  IO.select([s2])
  retry
rescue IO::WaitWritable
  IO.select(nil, [s2])
  retry
end

Durch Angabe eines Schlüsselwortarguments exception mit dem Wert false können Sie angeben, dass accept_nonblock keine IO::WaitReadable oder IO::WaitWritable Ausnahme auslösen soll, sondern stattdessen das Symbol :wait_readable oder :wait_writable zurückgeben soll.

alpn_protocol → String | nil

Source

static VALUE
ossl_ssl_alpn_protocol(VALUE self)
{
    SSL *ssl;
    const unsigned char *out;
    unsigned int outlen;

    GetSSL(self, ssl);

    SSL_get0_alpn_selected(ssl, &out, &outlen);
    if (!outlen)
        return Qnil;
    else
        return rb_str_new((const char *) out, outlen);
}

Gibt die ALPN-Protokollzeichenkette zurück, die vom Server während der Aushandlung ausgewählt wurde.

cert → cert or nil

Source

static VALUE
ossl_ssl_get_cert(VALUE self)
{
    SSL *ssl;
    X509 *cert = NULL;

    GetSSL(self, ssl);

    /*
     * Is this OpenSSL bug? Should add a ref?
     * TODO: Ask for.
     */
    cert = SSL_get_certificate(ssl); /* NO DUPs => DON'T FREE. */

    if (!cert) {
        return Qnil;
    }
    return ossl_x509_new(cert);
}

Das X509-Zertifikat für diesen Socket-Endpunkt.

cipher → nil or [name, version, bits, alg_bits]

Source

static VALUE
ossl_ssl_get_cipher(VALUE self)
{
    SSL *ssl;
    const SSL_CIPHER *cipher;

    GetSSL(self, ssl);
    cipher = SSL_get_current_cipher(ssl);
    return cipher ? ossl_ssl_cipher_to_ary(cipher) : Qnil;
}

Gibt die tatsächlich verwendete Cipher Suite der aktuellen Sitzung zurück, oder nil, wenn noch keine Sitzung hergestellt wurde.

client_ca → [x509name, ...] or nil

Source

static VALUE
ossl_ssl_get_client_ca_list(VALUE self)
{
    SSL *ssl;
    STACK_OF(X509_NAME) *ca;

    GetSSL(self, ssl);

    ca = SSL_get_client_CA_list(ssl);
    if (!ca)
        return Qnil;
    return ossl_x509name_sk2ary(ca);
}

Gibt die Liste der Client-CAs zurück. Bitte beachten Sie, dass im Gegensatz zu SSLContext#client_ca= kein Array von X509::Certificates zurückgegeben wird, sondern X509::Name-Instanzen des Distinguished Name des Subjekts der CA.

Im Servermodus wird die von SSLContext#client_ca= gesetzte Liste zurückgegeben. Im Clientmodus wird die vom Server gesendete Liste der Client-CAs zurückgegeben.

close_read ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 400
def close_read
  # Unsupported and ignored.
  # Just don't read any more.
end

Schließt den Stream für das Lesen. Diese Methode wird von OpenSSL ignoriert, da es keine sinnvolle Möglichkeit gibt, sie zu implementieren, existiert aber aus Kompatibilitätsgründen mit IO.

close_write ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 419
def close_write
  stop
end

Schließt den Stream für das Schreiben. Das Verhalten dieser Methode hängt von der Version von OpenSSL und dem verwendeten TLS-Protokoll ab.

Sendet eine "close_notify"-Warnung an den Peer.
Wartet nicht auf die Antwort-Warnung "close_notify" des Peers.

In TLS 1.2 und früher

Beim Empfang einer "close_notify"-Warnung wird mit einer eigenen "close_notify"-Warnung geantwortet und die Verbindung sofort heruntergefahren, wobei ausstehende Schreibvorgänge verworfen werden.

Daher führt diese Methode in TLS 1.2 zum vollständigen Herunterfahren der Verbindung. In TLS 1.3 bleibt die Verbindung nur noch zum Lesen offen.

connect → self

Source

static VALUE
ossl_ssl_connect(VALUE self)
{
    ossl_ssl_setup(self);

    return ossl_start_ssl(self, SSL_connect, "SSL_connect", Qfalse);
}

Initiiert eine SSL/TLS-Aushandlung mit einem Server.

connect_nonblock([options]) → self

Source

static VALUE
ossl_ssl_connect_nonblock(int argc, VALUE *argv, VALUE self)
{
    VALUE opts;
    rb_scan_args(argc, argv, "0:", &opts);

    ossl_ssl_setup(self);

    return ossl_start_ssl(self, SSL_connect, "SSL_connect", opts);
}

Initiiert die SSL/TLS-Aushandlung als Client im Non-Blocking-Modus.

# emulates blocking connect
begin
  ssl.connect_nonblock
rescue IO::WaitReadable
  IO.select([s2])
  retry
rescue IO::WaitWritable
  IO.select(nil, [s2])
  retry
end

Durch Angabe eines Schlüsselwortarguments exception mit dem Wert false können Sie angeben, dass connect_nonblock keine IO::WaitReadable oder IO::WaitWritable Ausnahme auslösen soll, sondern stattdessen das Symbol :wait_readable oder :wait_writable zurückgeben soll.

export_keying_material(label, length) → String

Source

static VALUE
ossl_ssl_export_keying_material(int argc, VALUE *argv, VALUE self)
{
    SSL *ssl;
    VALUE str;
    VALUE label;
    VALUE length;
    VALUE context;
    unsigned char *p;
    size_t len;
    int use_ctx = 0;
    unsigned char *ctx = NULL;
    size_t ctx_len = 0;
    int ret;

    rb_scan_args(argc, argv, "21", &label, &length, &context);
    StringValue(label);

    GetSSL(self, ssl);

    len = (size_t)NUM2LONG(length);
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if (!NIL_P(context)) {
        use_ctx = 1;
        StringValue(context);
        ctx = (unsigned char *)RSTRING_PTR(context);
        ctx_len = RSTRING_LEN(context);
    }
    ret = SSL_export_keying_material(ssl, p, len, (char *)RSTRING_PTR(label),
                                     RSTRING_LENINT(label), ctx, ctx_len, use_ctx);
    if (ret == 0 || ret == -1) {
        ossl_raise(eSSLError, "SSL_export_keying_material");
    }
    return str;
}

Ermöglicht die Verwendung von gemeinsam genutztem Sitzungsschlüsselmaterial gemäß RFC 5705.

finished_message → "finished message"

Source

static VALUE
ossl_ssl_get_finished(VALUE self)
{
    SSL *ssl;
    char sizer[1], *buf;
    size_t len;

    GetSSL(self, ssl);

    len = SSL_get_finished(ssl, sizer, 0);
    if (len == 0)
        return Qnil;

    buf = ALLOCA_N(char, len);
    SSL_get_finished(ssl, buf, len);
    return rb_str_new(buf, len);
}

Gibt die zuletzt gesendete Finished-Nachricht zurück.

group → String or nil

Source

static VALUE
ossl_ssl_get_group(VALUE self)
{
    SSL *ssl;
    const char *name;

    GetSSL(self, ssl);
    if (!(name = SSL_get0_group_name(ssl)))
        return Qnil;
    return rb_str_new_cstr(name);
}

Gibt den Namen der Gruppe zurück, die für die Schlüsselvereinbarung bei der aktuellen TLS-Sitzungseinrichtung verwendet wurde.

hostname = hostname → hostname

Source

static VALUE
ossl_ssl_set_hostname(VALUE self, VALUE arg)
{
    SSL *ssl;
    char *hostname = NULL;

    GetSSL(self, ssl);

    if (!NIL_P(arg))
        hostname = StringValueCStr(arg);

    if (!SSL_set_tlsext_host_name(ssl, hostname))
        ossl_raise(eSSLError, NULL);

    /* for SSLSocket#hostname */
    rb_ivar_set(self, id_i_hostname, arg);

    return arg;
}

Setzt den Servernamen, der für SNI verwendet wird. Dies muss vor SSLSocket#connect gesetzt werden.

npn_protocol → String | nil

Source

static VALUE
ossl_ssl_npn_protocol(VALUE self)
{
    SSL *ssl;
    const unsigned char *out;
    unsigned int outlen;

    GetSSL(self, ssl);

    SSL_get0_next_proto_negotiated(ssl, &out, &outlen);
    if (!outlen)
        return Qnil;
    else
        return rb_str_new((const char *) out, outlen);
}

Gibt die Protokollzeichenkette zurück, die vom Client während der Aushandlung ausgewählt wurde.

peer_cert → cert or nil

Source

static VALUE
ossl_ssl_get_peer_cert(VALUE self)
{
    SSL *ssl;
    X509 *cert = NULL;
    VALUE obj;

    GetSSL(self, ssl);

    cert = SSL_get_peer_certificate(ssl); /* Adds a ref => Safe to FREE. */

    if (!cert) {
        return Qnil;
    }
    obj = ossl_x509_new(cert);
    X509_free(cert);

    return obj;
}

Das X509-Zertifikat für den Peer dieses Sockets.

peer_cert_chain → [cert, ...] or nil

Source

static VALUE
ossl_ssl_get_peer_cert_chain(VALUE self)
{
    SSL *ssl;
    STACK_OF(X509) *chain;
    X509 *cert;
    VALUE ary;
    int i, num;

    GetSSL(self, ssl);

    chain = SSL_get_peer_cert_chain(ssl);
    if(!chain) return Qnil;
    num = sk_X509_num(chain);
    ary = rb_ary_new2(num);
    for (i = 0; i < num; i++){
        cert = sk_X509_value(chain, i);
        rb_ary_push(ary, ossl_x509_new(cert));
    }

    return ary;
}

Die X509-Zertifikatkette für den Peer dieses Sockets.

peer_finished_message → "peer finished message"

Source

static VALUE
ossl_ssl_get_peer_finished(VALUE self)
{
    SSL *ssl;
    char sizer[1], *buf;
    size_t len;

    GetSSL(self, ssl);

    len = SSL_get_peer_finished(ssl, sizer, 0);
    if (len == 0)
        return Qnil;

    buf = ALLOCA_N(char, len);
    SSL_get_peer_finished(ssl, buf, len);
    return rb_str_new(buf, len);
}

Gibt die zuletzt empfangene Finished-Nachricht zurück.

peer_sigalg → String or nil

Source

static VALUE
ossl_ssl_get_peer_sigalg(VALUE self)
{
    SSL *ssl;
    const char *name;

    GetSSL(self, ssl);
    if (!SSL_get0_peer_signature_name(ssl, &name))
        return Qnil;
    return rb_str_new_cstr(name);
}

Gibt den Namen des Signaturalgorithmus zurück, den IANA-Namen des Signaturschemas, das vom Peer zur Signierung des TLS-Handshakes verwendet wurde.

pending → Integer

Source

static VALUE
ossl_ssl_pending(VALUE self)
{
    SSL *ssl;

    GetSSL(self, ssl);

    return INT2NUM(SSL_pending(ssl));
}

Die Anzahl der Bytes, die sofort zum Lesen verfügbar sind.

post_connection_check(hostname) → true

Source

# File ext/openssl/lib/openssl/ssl.rb, line 370
def post_connection_check(hostname)
  if peer_cert.nil?
    msg = "Peer verification enabled, but no certificate received."
    if using_anon_cipher?
      msg += " Anonymous cipher suite #{cipher[0]} was negotiated. " \
             "Anonymous suites must be disabled to use peer verification."
    end
    raise SSLError, msg
  end

  unless OpenSSL::SSL.verify_certificate_identity(peer_cert, hostname)
    raise SSLError, "hostname \"#{hostname}\" does not match the server certificate"
  end
  return true
end

Führt die Hostnamen-Überprüfung gemäß RFC 6125 durch.

Diese Methode MUSS aufgerufen werden, nachdem connect aufgerufen wurde, um sicherzustellen, dass der Hostname eines entfernten Peers überprüft wurde.

session → aSession

Source

# File ext/openssl/lib/openssl/ssl.rb, line 391
def session
  SSL::Session.new(self)
rescue SSL::Session::SessionError
  nil
end

Gibt das aktuell verwendete SSLSession-Objekt zurück, oder nil, wenn die Sitzung nicht hergestellt wurde.

session = session → session

Source

static VALUE
ossl_ssl_set_session(VALUE self, VALUE arg1)
{
    SSL *ssl;
    SSL_SESSION *sess;

    GetSSL(self, ssl);
    GetSSLSession(arg1, sess);

    if (SSL_set_session(ssl, sess) != 1)
        ossl_raise(eSSLError, "SSL_set_session");

    return arg1;
}

Setzt die zu verwendende Session, wenn die Verbindung hergestellt wird.

session_reused? → true | false

Source

static VALUE
ossl_ssl_session_reused(VALUE self)
{
    SSL *ssl;

    GetSSL(self, ssl);

    return SSL_session_reused(ssl) ? Qtrue : Qfalse;
}

Gibt true zurück, wenn während der Aushandlung eine wiederverwendete Sitzung ausgehandelt wurde.

sigalg → String or nil

Source

static VALUE
ossl_ssl_get_sigalg(VALUE self)
{
    SSL *ssl;
    const char *name;

    GetSSL(self, ssl);
    if (!SSL_get0_signature_name(ssl, &name))
        return Qnil;
    return rb_str_new_cstr(name);
}

Gibt den Namen des Signaturalgorithmus zurück, den IANA-Namen des Signaturschemas, das lokal zur Signierung des TLS-Handshakes verwendet wurde.

ssl_version → String

Source

static VALUE
ossl_ssl_get_version(VALUE self)
{
    SSL *ssl;

    GetSSL(self, ssl);

    return rb_str_new2(SSL_get_version(ssl));
}

Gibt eine String zurück, die die für die Verbindung ausgehandelte SSL/TLS-Version darstellt, z. B. "TLSv1.2".

state → string

Source

static VALUE
ossl_ssl_get_state(VALUE self)
{
    SSL *ssl;
    VALUE ret;

    GetSSL(self, ssl);

    ret = rb_str_new2(SSL_state_string(ssl));
    if (ruby_verbose) {
        rb_str_cat2(ret, ": ");
        rb_str_cat2(ret, SSL_state_string_long(ssl));
    }
    return ret;
}

Eine Beschreibung des aktuellen Verbindungsstatus. Dies dient nur zu Diagnosezwecken.

sysclose → nil

Source

# File ext/openssl/lib/openssl/ssl.rb, line 357
def sysclose
  return if closed?
  stop
  io.close if sync_close
end

Sendet "close notify" an den Peer und versucht, die SSL-Verbindung ordnungsgemäß zu beenden.

Wenn sync_close auf true gesetzt ist, wird auch der zugrunde liegende IO geschlossen.

sysread(length) → string

sysread(length, buffer) → buffer

Source

static VALUE
ossl_ssl_read(int argc, VALUE *argv, VALUE self)
{
    return ossl_ssl_read_internal(argc, argv, self, 0);
}

Liest length Bytes aus der SSL-Verbindung. Wenn ein vorab zugewiesener buffer bereitgestellt wird, werden die Daten darin geschrieben.

syswrite(string) → Integer

Source

static VALUE
ossl_ssl_write(VALUE self, VALUE str)
{
    return ossl_ssl_write_internal(self, str, Qfalse);
}

Schreibt string in die SSL-Verbindung.

tmp_key → PKey or nil

Source

static VALUE
ossl_ssl_tmp_key(VALUE self)
{
    SSL *ssl;
    EVP_PKEY *key;

    GetSSL(self, ssl);
    if (!SSL_get_server_tmp_key(ssl, &key))
        return Qnil;
    return ossl_pkey_wrap(key);
}

Gibt den temporären Schlüssel zurück, der bei Ciphern mit Forward Secrecy verwendet wird.

verify_result → Integer

Source

static VALUE
ossl_ssl_get_verify_result(VALUE self)
{
    SSL *ssl;

    GetSSL(self, ssl);

    return LONG2NUM(SSL_get_verify_result(ssl));
}

Gibt das Ergebnis der Verifizierung der Peer-Zertifikate zurück. Siehe verify(1) für Fehlerwerte und Beschreibungen.

Wenn kein Peer-Zertifikat präsentiert wurde, wird X509_V_OK zurückgegeben.

Private Instanzmethoden

client_cert_cb ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 431
def client_cert_cb
  @context.client_cert_cb
end

session_get_cb ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 439
def session_get_cb
  @context.session_get_cb
end

session_new_cb ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 435
def session_new_cb
  @context.session_new_cb
end

stop → nil

Source

static VALUE
ossl_ssl_stop(VALUE self)
{
    SSL *ssl;
    int ret;

    GetSSL(self, ssl);
    if (!ssl_started(ssl))
        return Qnil;
    ret = SSL_shutdown(ssl);
    if (ret == 1) /* Have already received close_notify */
        return Qnil;
    if (ret == 0) /* Sent close_notify, but we don't wait for reply */
        return Qnil;

    /*
     * XXX: Something happened. Possibly it failed because the underlying socket
     * is not writable/readable, since it is in non-blocking mode. We should do
     * some proper error handling using SSL_get_error() and maybe retry, but we
     * can't block here. Give up for now.
     */
    ossl_clear_error();
    return Qnil;
}

Sendet "close notify" an den Peer und versucht, die SSL-Verbindung ordnungsgemäß zu beenden.

sysread_nonblock(length) → string

sysread_nonblock(length, buffer) → buffer

sysread_nonblock(length[, buffer [, opts]) → buffer

Source

static VALUE
ossl_ssl_read_nonblock(int argc, VALUE *argv, VALUE self)
{
    return ossl_ssl_read_internal(argc, argv, self, 1);
}

Eine Non-Blocking-Version von sysread. Löst eine SSLError aus, wenn das Lesen blockieren würde. Wenn "exception: false" übergeben wird, gibt diese Methode ein Symbol wie :wait_readable, :wait_writable oder nil zurück, anstatt eine Ausnahme auszulösen.

Liest length Bytes aus der SSL-Verbindung. Wenn ein vorab zugewiesener buffer bereitgestellt wird, werden die Daten darin geschrieben.

syswrite_nonblock(string) → Integer

Source

static VALUE
ossl_ssl_write_nonblock(int argc, VALUE *argv, VALUE self)
{
    VALUE str, opts;

    rb_scan_args(argc, argv, "1:", &str, &opts);

    return ossl_ssl_write_internal(self, str, opts);
}

Schreibt string nicht-blockierend in die SSL-Verbindung. Löst eine SSLError aus, wenn das Schreiben blockieren würde.

using_anon_cipher? ()

Source

# File ext/openssl/lib/openssl/ssl.rb, line 425
def using_anon_cipher?
  ctx = OpenSSL::SSL::SSLContext.new
  ctx.ciphers = "aNULL"
  ctx.ciphers.include?(cipher)
end