class OpenSSL::PKey::RSA

RSA ist ein asymmetrischer Public-Key-Algorithmus, der in RFC 3447 formalisiert wurde. Er ist weit verbreitet in Public-Key-Infrastrukturen (PKI), wo Zertifikate (siehe OpenSSL::X509::Certificate) oft auf der Grundlage eines öffentlichen/privaten RSA-Schlüsselpaares ausgestellt werden. RSA wird in einer Vielzahl von Anwendungen eingesetzt, z. B. für den sicheren (symmetrischen) Schlüsselaustausch, z. B. bei der Einrichtung einer sicheren TLS/SSL-Verbindung. Er wird auch in verschiedenen digitalen Signaturverfahren verwendet.

Constants

NO_PADDING
PKCS1_OAEP_PADDING
PKCS1_PADDING
SSLV23_PADDING

Öffentliche Klassenmethoden

generate(size, exponent = 65537) → RSA

Source

# File ext/openssl/lib/openssl/pkey.rb, line 381
def generate(size, exp = 0x10001, &blk)
  OpenSSL::PKey.generate_key("RSA", {
    "rsa_keygen_bits" => size,
    "rsa_keygen_pubexp" => exp,
  }, &blk)
end

Generiert ein RSA-Schlüsselpaar.

Siehe auch OpenSSL::PKey.generate_key.

size: Die gewünschte Schlüsselgröße in Bits.
exponent: Eine ungerade Integer, normalerweise 3, 17 oder 65537.

new → rsa

new(encoded_key [, password ]) → rsa

new(encoded_key) { password } → rsa

new(size [, exponent]) → rsa

Source

static VALUE
ossl_rsa_initialize(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    RSA *rsa;
    BIO *in = NULL;
    VALUE arg, pass;
    int type;

    TypedData_Get_Struct(self, EVP_PKEY, &ossl_evp_pkey_type, pkey);
    if (pkey)
        rb_raise(rb_eTypeError, "pkey already initialized");

    /* The RSA.new(size, generator) form is handled by lib/openssl/pkey.rb */
    rb_scan_args(argc, argv, "02", &arg, &pass);
    if (argc == 0) {
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
        rb_raise(rb_eArgError, "OpenSSL::PKey::RSA.new cannot be called " \
                 "without arguments; pkeys are immutable with OpenSSL 3.0");
#else
        rsa = RSA_new();
        if (!rsa)
            ossl_raise(ePKeyError, "RSA_new");
        goto legacy;
#endif
    }

    pass = ossl_pem_passwd_value(pass);
    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(&arg);

    /* First try RSAPublicKey format */
    rsa = d2i_RSAPublicKey_bio(in, NULL);
    if (rsa)
        goto legacy;
    OSSL_BIO_reset(in);
    rsa = PEM_read_bio_RSAPublicKey(in, NULL, NULL, NULL);
    if (rsa)
        goto legacy;
    OSSL_BIO_reset(in);

    /* Use the generic routine */
    pkey = ossl_pkey_read_generic(in, pass);
    BIO_free(in);
    if (!pkey)
        ossl_raise(ePKeyError, "Neither PUB key nor PRIV key");

    type = EVP_PKEY_base_id(pkey);
    if (type != EVP_PKEY_RSA) {
        EVP_PKEY_free(pkey);
        rb_raise(ePKeyError, "incorrect pkey type: %s", OBJ_nid2sn(type));
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;

  legacy:
    BIO_free(in);
    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
        EVP_PKEY_free(pkey);
        RSA_free(rsa);
        ossl_raise(ePKeyError, "EVP_PKEY_assign_RSA");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

Generiert oder lädt ein RSA-Schlüsselpaar.

Wenn ohne Argumente aufgerufen, wird eine neue Instanz ohne gesetzte Schlüsselkomponenten erstellt. Diese können einzeln über set_key, set_factors und set_crt_params gesetzt werden. Diese Form ist nicht kompatibel mit OpenSSL 3.0 oder neuer.

Wenn mit einer String aufgerufen, wird versucht, diese als DER- oder PEM-Codierung eines RSA-Schlüssels zu parsen. Beachten Sie, dass, wenn password nicht angegeben ist, aber der Schlüssel mit einem Passwort verschlüsselt ist, OpenSSL danach fragen wird. Siehe auch OpenSSL::PKey.read, das Schlüssel jeder Art parsen kann.

Wenn mit einer Zahl aufgerufen, wird ein neues Schlüsselpaar generiert. Diese Form funktioniert als Alias für RSA.generate.

Beispiele

OpenSSL::PKey::RSA.new 2048
OpenSSL::PKey::RSA.new File.read 'rsa.pem'
OpenSSL::PKey::RSA.new File.read('rsa.pem'), 'my password'

Öffentliche Instanzmethoden

export([cipher, password]) → PEM-formatierte String

Source

static VALUE
ossl_rsa_export(int argc, VALUE *argv, VALUE self)
{
    if (can_export_rsaprivatekey(self))
        return ossl_pkey_export_traditional(argc, argv, self, 0);
    else
        return ossl_pkey_export_spki(self, 0);
}

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Erwägen Sie die Verwendung von public_to_pem stattdessen. Dies serialisiert den Schlüssel in eine X.509 SubjectPublicKeyInfo, unabhängig davon, ob es sich um einen öffentlichen oder privaten Schlüssel handelt.

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen PKCS #1 RSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
[...]
-----END RSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Serialisiert ihn in einen PKCS #1 RSAPrivateKey und verschlüsselt ihn im traditionellen PEM-Verschlüsselungsformat von OpenSSL. cipher muss ein von OpenSSL::Cipher.new verstandener Ciphername oder eine Instanz von OpenSSL::Cipher sein.

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END RSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das PKCS #1 RSAPrivateKey-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Auch aliasisiert als: to_pem, to_s

params → hash

Source

# File ext/openssl/lib/openssl/pkey.rb, line 363
def params
  %w{n e d p q dmp1 dmq1 iqmp}.map { |name|
    [name, send(name)]
  }.to_h
end

Speichert alle Parameter des Schlüssels in einem Hash.

Der Hash hat die Schlüssel 'n', 'e', 'd', 'p', 'q', 'dmp1', 'dmq1' und 'iqmp'.

private? → true | false

Source

static VALUE
ossl_rsa_is_private(VALUE self)
{
    OSSL_3_const RSA *rsa;

    GetRSA(self, rsa);

    return RSA_PRIVATE(self, rsa) ? Qtrue : Qfalse;
}

Enthält dieses Schlüsselpaar einen privaten Schlüssel?

private_decrypt(string) → String

private_decrypt(string, padding) → String

Source

# File ext/openssl/lib/openssl/pkey.rb, line 465
def private_decrypt(data, padding = PKCS1_PADDING)
  n or raise PKeyError, "incomplete RSA"
  private? or raise PKeyError, "private key needed."
  decrypt(data, {
    "rsa_padding_mode" => translate_padding_mode(padding),
  })
end

Entschlüsselt string, das mit dem öffentlichen Schlüssel verschlüsselt wurde, mit dem privaten Schlüssel. padding ist standardmäßig PKCS1_PADDING, das bekanntermaßen unsicher ist, aber aus Kompatibilitätsgründen beibehalten wird.

Veraltet in Version 3.0. Erwägen Sie die Verwendung von PKey::PKey#encrypt und PKey::PKey#decrypt stattdessen.

private_encrypt(string) → String

private_encrypt(string, padding) → String

Source

# File ext/openssl/lib/openssl/pkey.rb, line 411
def private_encrypt(string, padding = PKCS1_PADDING)
  n or raise PKeyError, "incomplete RSA"
  private? or raise PKeyError, "private key needed."
  sign_raw(nil, string, {
    "rsa_padding_mode" => translate_padding_mode(padding),
  })
end

Verschlüsselt string mit dem privaten Schlüssel. padding ist standardmäßig PKCS1_PADDING, das bekanntermaßen unsicher ist, aber aus Kompatibilitätsgründen beibehalten wird. Die verschlüsselte String-Ausgabe kann mit public_decrypt entschlüsselt werden.

Veraltet in Version 3.0. Erwägen Sie die Verwendung von PKey::PKey#sign_raw und PKey::PKey#verify_raw sowie PKey::PKey#verify_recover stattdessen.

public? → true

Source

static VALUE
ossl_rsa_is_public(VALUE self)
{
    OSSL_3_const RSA *rsa;

    GetRSA(self, rsa);
    /*
     * This method should check for n and e.  BUG.
     */
    (void)rsa;
    return Qtrue;
}

Der Rückgabewert ist immer true, da jeder private Schlüssel auch ein öffentlicher Schlüssel ist.

public_decrypt(string) → String

public_decrypt(string, padding) → String

Source

# File ext/openssl/lib/openssl/pkey.rb, line 430
def public_decrypt(string, padding = PKCS1_PADDING)
  n or raise PKeyError, "incomplete RSA"
  verify_recover(nil, string, {
    "rsa_padding_mode" => translate_padding_mode(padding),
  })
end

Entschlüsselt string, das mit dem privaten Schlüssel verschlüsselt wurde, mit dem öffentlichen Schlüssel. padding ist standardmäßig PKCS1_PADDING, das bekanntermaßen unsicher ist, aber aus Kompatibilitätsgründen beibehalten wird.

Veraltet in Version 3.0. Erwägen Sie die Verwendung von PKey::PKey#sign_raw und PKey::PKey#verify_raw sowie PKey::PKey#verify_recover stattdessen.

public_encrypt(string) → String

public_encrypt(string, padding) → String

Source

# File ext/openssl/lib/openssl/pkey.rb, line 448
def public_encrypt(data, padding = PKCS1_PADDING)
  n or raise PKeyError, "incomplete RSA"
  encrypt(data, {
    "rsa_padding_mode" => translate_padding_mode(padding),
  })
end

Verschlüsselt string mit dem öffentlichen Schlüssel. padding ist standardmäßig PKCS1_PADDING, das bekanntermaßen unsicher ist, aber aus Kompatibilitätsgründen beibehalten wird. Die verschlüsselte String-Ausgabe kann mit private_decrypt entschlüsselt werden.

Veraltet in Version 3.0. Erwägen Sie die Verwendung von PKey::PKey#encrypt und PKey::PKey#decrypt stattdessen.

public_key → rsanew

Source

# File ext/openssl/lib/openssl/pkey.rb, line 353
def public_key
  OpenSSL::PKey.read(public_to_der)
end

Gibt eine neue RSA-Instanz zurück, die nur die öffentlichen Schlüsselkomponenten enthält.

Diese Methode wird aus Gründen der Abwärtskompatibilität bereitgestellt. In den meisten Fällen ist es nicht erforderlich, diese Methode aufzurufen.

Für die Serialisierung des öffentlichen Schlüssels in PEM- oder DER-Codierung im X.509 SubjectPublicKeyInfo-Format siehe PKey#public_to_pem und PKey#public_to_der.

set_crt_params(dmp1, dmq1, iqmp) → self

Setzt dmp1, dmq1, iqmp für die RSA-Instanz. Diese werden berechnet als d mod (p - 1), d mod (q - 1) bzw. q^(-1) mod p.

set_factors(p, q) → self

Setzt p, q für die RSA-Instanz.

set_key(n, e, d) → self

Setzt n, e, d für die RSA-Instanz.

sign_pss(digest, data, salt_length:, mgf1_hash:) → String

Source

static VALUE
ossl_rsa_sign_pss(int argc, VALUE *argv, VALUE self)
{
    VALUE digest, data, options, kwargs[2], signature, mgf1md_holder, md_holder;
    static ID kwargs_ids[2];
    EVP_PKEY *pkey;
    EVP_PKEY_CTX *pkey_ctx;
    const EVP_MD *md, *mgf1md;
    EVP_MD_CTX *md_ctx;
    size_t buf_len;
    int salt_len;

    if (!kwargs_ids[0]) {
        kwargs_ids[0] = rb_intern_const("salt_length");
        kwargs_ids[1] = rb_intern_const("mgf1_hash");
    }
    rb_scan_args(argc, argv, "2:", &digest, &data, &options);
    rb_get_kwargs(options, kwargs_ids, 2, 0, kwargs);
    if (kwargs[0] == ID2SYM(rb_intern("max")))
        salt_len = -2; /* RSA_PSS_SALTLEN_MAX_SIGN */
    else if (kwargs[0] == ID2SYM(rb_intern("digest")))
        salt_len = -1; /* RSA_PSS_SALTLEN_DIGEST */
    else
        salt_len = NUM2INT(kwargs[0]);
    mgf1md = ossl_evp_md_fetch(kwargs[1], &mgf1md_holder);

    pkey = GetPrivPKeyPtr(self);
    buf_len = EVP_PKEY_size(pkey);
    md = ossl_evp_md_fetch(digest, &md_holder);
    StringValue(data);
    signature = rb_str_new(NULL, (long)buf_len);

    md_ctx = EVP_MD_CTX_new();
    if (!md_ctx)
        goto err;

    if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, salt_len) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1md) != 1)
        goto err;

    if (EVP_DigestSignUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1)
        goto err;

    if (EVP_DigestSignFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), &buf_len) != 1)
        goto err;

    rb_str_set_len(signature, (long)buf_len);

    EVP_MD_CTX_free(md_ctx);
    return signature;

  err:
    EVP_MD_CTX_free(md_ctx);
    ossl_raise(ePKeyError, NULL);
}

Signiert data mithilfe des Probabilistic Signature Scheme (RSA-PSS) und gibt die berechnete Signatur zurück.

PKeyError wird ausgelöst, wenn ein Fehler auftritt.

Siehe verify_pss für die Verifizierungsoperation.

Parameter

digest: Eine String mit dem Namen des Digest-Algorithmus.
Daten: Eine String. Die zu signierenden Daten.
salt_length: Die Länge des Salts in Oktetten. Zwei Sonderwerte sind reserviert: :digest bedeutet die Digest-Länge und :max bedeutet die maximal mögliche Länge für die Kombination des privaten Schlüssels und des ausgewählten Nachrichtendigest-Algorithmus.
mgf1_hash: Der Hash-Algorithmus, der in MGF1 verwendet wird (die derzeit unterstützte Maskengenerierungsfunktion (MGF)).

Beispiel

data = "Sign me!"
pkey = OpenSSL::PKey::RSA.new(2048)
signature = pkey.sign_pss("SHA256", data, salt_length: :max, mgf1_hash: "SHA256")
pub_key = OpenSSL::PKey.read(pkey.public_to_der)
puts pub_key.verify_pss("SHA256", signature, data,
                        salt_length: :auto, mgf1_hash: "SHA256") # => true

to_der → DER-formatierte String

Source

static VALUE
ossl_rsa_to_der(VALUE self)
{
    if (can_export_rsaprivatekey(self))
        return ossl_pkey_export_traditional(0, NULL, self, 1);
    else
        return ossl_pkey_export_spki(self, 1);
}

Serialisiert einen privaten oder öffentlichen Schlüssel in DER-Kodierung.

Siehe to_pem für Details.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das PKCS #1 RSAPrivateKey-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_der oder private_to_der.

to_pem([cipher, password]) → PEM-formatierte String

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen PKCS #1 RSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
[...]
-----END RSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END RSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das PKCS #1 RSAPrivateKey-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Alias für: export

to_s([cipher, password]) → PEM-formatierte String

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen PKCS #1 RSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
[...]
-----END RSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END RSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das PKCS #1 RSAPrivateKey-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Alias für: export

verify_pss(digest, signature, data, salt_length:, mgf1_hash:) → true | false

Source

static VALUE
ossl_rsa_verify_pss(int argc, VALUE *argv, VALUE self)
{
    VALUE digest, signature, data, options, kwargs[2], mgf1md_holder, md_holder;
    static ID kwargs_ids[2];
    EVP_PKEY *pkey;
    EVP_PKEY_CTX *pkey_ctx;
    const EVP_MD *md, *mgf1md;
    EVP_MD_CTX *md_ctx;
    int result, salt_len;

    if (!kwargs_ids[0]) {
        kwargs_ids[0] = rb_intern_const("salt_length");
        kwargs_ids[1] = rb_intern_const("mgf1_hash");
    }
    rb_scan_args(argc, argv, "3:", &digest, &signature, &data, &options);
    rb_get_kwargs(options, kwargs_ids, 2, 0, kwargs);
    if (kwargs[0] == ID2SYM(rb_intern("auto")))
        salt_len = -2; /* RSA_PSS_SALTLEN_AUTO */
    else if (kwargs[0] == ID2SYM(rb_intern("digest")))
        salt_len = -1; /* RSA_PSS_SALTLEN_DIGEST */
    else
        salt_len = NUM2INT(kwargs[0]);
    mgf1md = ossl_evp_md_fetch(kwargs[1], &mgf1md_holder);

    GetPKey(self, pkey);
    md = ossl_evp_md_fetch(digest, &md_holder);
    StringValue(signature);
    StringValue(data);

    md_ctx = EVP_MD_CTX_new();
    if (!md_ctx)
        goto err;

    if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, salt_len) != 1)
        goto err;

    if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1md) != 1)
        goto err;

    if (EVP_DigestVerifyUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1)
        goto err;

    result = EVP_DigestVerifyFinal(md_ctx,
                                   (unsigned char *)RSTRING_PTR(signature),
                                   RSTRING_LEN(signature));
    EVP_MD_CTX_free(md_ctx);

    switch (result) {
      case 0:
        ossl_clear_error();
        return Qfalse;
      case 1:
        return Qtrue;
      default:
        ossl_raise(ePKeyError, "EVP_DigestVerifyFinal");
    }

  err:
    EVP_MD_CTX_free(md_ctx);
    ossl_raise(ePKeyError, NULL);
}

Verifiziert data mithilfe des Probabilistic Signature Scheme (RSA-PSS).

Der Rückgabewert ist true, wenn die Signatur gültig ist, andernfalls false. PKeyError wird ausgelöst, wenn ein Fehler auftritt.

Siehe sign_pss für die Signieroperation und ein Beispielcode.

Parameter

digest: Eine String mit dem Namen des Digest-Algorithmus.
Daten: Eine String. Die zu signierenden Daten.
salt_length: Die Länge des Salts in Oktetten. Zwei Sonderwerte sind reserviert: :digest bedeutet die Digest-Länge und :auto bedeutet die automatische Bestimmung der Länge basierend auf der Signatur.
mgf1_hash: Der Hash-Algorithmus, der in MGF1 verwendet wird.

Private Instanzmethoden

translate_padding_mode (num)

Source

# File ext/openssl/lib/openssl/pkey.rb, line 478
        def translate_padding_mode(num)
  case num
  when PKCS1_PADDING
    "pkcs1"
  when SSLV23_PADDING
    "sslv23"
  when NO_PADDING
    "none"
  when PKCS1_OAEP_PADDING
    "oaep"
  else
    raise PKeyError, "unsupported padding mode"
  end
end