класс OpenSSL::PKey::RSA

Родительский класс:: OpenSSL::PKey::PKey
Подключенные модули:: OpenSSL::Marshal

RSA — это алгоритм асимметричного открытого ключа, формализованный в RFC 3447. Он широко используется в инфраструктурах открытых ключей (PKI), где сертификаты (см. OpenSSL::X509::Certificate) часто выпускаются на основе пары открытого и закрытого ключей RSA. RSA применяется в самых разных областях, например для безопасного обмена (симметричными) ключами, в частности при установлении защищенного TLS/SSL-соединения. Также он используется в различных схемах цифровой подписи.

Константы

NO_PADDING
PKCS1_OAEP_PADDING
PKCS1_PADDING
SSLV23_PADDING

Публичные методы класса

generate(size, exponent = 65537) → RSA Показать исходный код

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

Генерирует пару ключей RSA.

См. также OpenSSL::PKey.generate_key.

size: Требуемый размер ключа в битах.
exponent: Нечетное значение Integer, обычно 3, 17 или 65537.

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

new(encoded_key [, password ]) → rsa

new(encoded_key) { password } → rsa

new(size [, exponent]) → rsa

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) {
        rsa = RSA_new();
        if (!rsa)
            ossl_raise(eRSAError, "RSA_new");
        goto legacy;
    }

    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(eRSAError, "Neither PUB key nor PRIV key");

    type = EVP_PKEY_base_id(pkey);
    if (type != EVP_PKEY_RSA) {
        EVP_PKEY_free(pkey);
        rb_raise(eRSAError, "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(eRSAError, "EVP_PKEY_assign_RSA");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

Генерирует или загружает пару ключей RSA.

Если вызван без аргументов, создает новый экземпляр без заданных компонентов ключа. Их можно задать по отдельности с помощью set_key, set_factors и set_crt_params.

Если вызван со значением типа String, пытается разобрать его как ключ RSA в кодировке DER или PEM. Обратите внимание: если password не указан, но ключ зашифрован паролем, OpenSSL запросит его. См. также OpenSSL::PKey.read, который может разбирать ключи любого типа.

Если вызван с числом, генерирует новую пару ключей. Эта форма является псевдонимом RSA.generate.

Примеры:

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

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

export([cipher, password]) → PEM-format String Показать исходный код

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

Сериализует закрытый или открытый ключ в кодировку PEM.

Если ключ содержит только компоненты открытого ключа

Сериализует его в формате X.509 SubjectPublicKeyInfo. Параметры cipher и password игнорируются.

Ключ в кодировке PEM будет выглядеть так:

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

Вместо этого рассмотрите возможность использовать public_to_pem. Этот метод сериализует ключ в формате X.509 SubjectPublicKeyInfo независимо от того, является ли ключ открытым или закрытым.

Если ключ содержит компоненты закрытого ключа и параметры не заданы

Сериализует его в формате PKCS #1 RSAPrivateKey.

Ключ в кодировке PEM будет выглядеть так:

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

Если ключ содержит компоненты закрытого ключа и заданы параметры cipher и password

Сериализует его в формате PKCS #1 RSAPrivateKey и шифрует в традиционном формате шифрования PEM OpenSSL. cipher должен быть именем шифра, распознаваемым OpenSSL::Cipher.new, или экземпляром OpenSSL::Cipher.

Зашифрованный ключ в кодировке PEM будет выглядеть так:

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

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

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

Этот метод сохранен для обратной совместимости. Его следует использовать только в случаях, когда требуется формат PKCS #1 RSAPrivateKey.

Вместо этого рассмотрите возможность использовать public_to_pem (X.509 SubjectPublicKeyInfo) или private_to_pem (PKCS #8 PrivateKeyInfo или EncryptedPrivateKeyInfo).

Также имеет псевдонимы: to_pem, to_s

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

HAVE_EVP_PKEY_DUP
static VALUE
ossl_rsa_initialize_copy(VALUE self, VALUE other)
{
    EVP_PKEY *pkey;
    RSA *rsa, *rsa_new;

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

    rsa_new = (RSA *)ASN1_dup((i2d_of_void *)i2d_RSAPrivateKey,
                              (d2i_of_void *)d2i_RSAPrivateKey,
                              (char *)rsa);
    if (!rsa_new)
        ossl_raise(eRSAError, "ASN1_dup");

    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_RSA(pkey, rsa_new) != 1) {
        RSA_free(rsa_new);
        ossl_raise(eRSAError, "EVP_PKEY_assign_RSA");
    }
    RTYPEDDATA_DATA(self) = pkey;

    return self;
}

params → hash Показать исходный код

static VALUE
ossl_rsa_get_params(VALUE self)
{
    OSSL_3_const RSA *rsa;
    VALUE hash;
    const BIGNUM *n, *e, *d, *p, *q, *dmp1, *dmq1, *iqmp;

    GetRSA(self, rsa);
    RSA_get0_key(rsa, &n, &e, &d);
    RSA_get0_factors(rsa, &p, &q);
    RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp);

    hash = rb_hash_new();
    rb_hash_aset(hash, rb_str_new2("n"), ossl_bn_new(n));
    rb_hash_aset(hash, rb_str_new2("e"), ossl_bn_new(e));
    rb_hash_aset(hash, rb_str_new2("d"), ossl_bn_new(d));
    rb_hash_aset(hash, rb_str_new2("p"), ossl_bn_new(p));
    rb_hash_aset(hash, rb_str_new2("q"), ossl_bn_new(q));
    rb_hash_aset(hash, rb_str_new2("dmp1"), ossl_bn_new(dmp1));
    rb_hash_aset(hash, rb_str_new2("dmq1"), ossl_bn_new(dmq1));
    rb_hash_aset(hash, rb_str_new2("iqmp"), ossl_bn_new(iqmp));

    return hash;
}

ЭТОТ МЕТОД НЕБЕЗОПАСЕН: МОЖЕТ ПРОИЗОЙТИ УТЕЧКА ЗАКРЫТОЙ ИНФОРМАЦИИ!!!

Сохраняет все параметры ключа в хеш. Ключи хеша: ‘n’, ‘e’, ‘d’, ‘p’, ‘q’, ‘dmp1’, ‘dmq1’, ‘iqmp’.

Не используйте :-)) (Решать вам)

private? → true | false Показать исходный код

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

    GetRSA(self, rsa);

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

Содержит ли эта пара ключей закрытый ключ?

private_decrypt(string) → String Показать исходный код

private_decrypt(string, padding) → String

# File ext/openssl/lib/openssl/pkey.rb, line 439
def private_decrypt(data, padding = PKCS1_PADDING)
  n or raise OpenSSL::PKey::RSAError, "incomplete RSA"
  private? or raise OpenSSL::PKey::RSAError, "private key needed."
  begin
    decrypt(data, {
      "rsa_padding_mode" => translate_padding_mode(padding),
    })
  rescue OpenSSL::PKey::PKeyError
    raise OpenSSL::PKey::RSAError, $!.message
  end
end

Расшифровывает string закрытым ключом; данные должны быть зашифрованы открытым ключом. padding по умолчанию равен PKCS1_PADDING. Этот режим считается небезопасным, но сохранен для обратной совместимости.

Устарел в версии 3.0. Вместо этого рассмотрите возможность использовать PKey::PKey#encrypt и PKey::PKey#decrypt.

private_encrypt(string) → String Показать исходный код

private_encrypt(string, padding) → String

# File ext/openssl/lib/openssl/pkey.rb, line 373
def private_encrypt(string, padding = PKCS1_PADDING)
  n or raise OpenSSL::PKey::RSAError, "incomplete RSA"
  private? or raise OpenSSL::PKey::RSAError, "private key needed."
  begin
    sign_raw(nil, string, {
      "rsa_padding_mode" => translate_padding_mode(padding),
    })
  rescue OpenSSL::PKey::PKeyError
    raise OpenSSL::PKey::RSAError, $!.message
  end
end

Зашифровывает string закрытым ключом. padding по умолчанию равен PKCS1_PADDING. Этот режим считается небезопасным, но сохранен для обратной совместимости. Полученную зашифрованную строку можно расшифровать с помощью public_decrypt.

Устарел в версии 3.0. Вместо этого рассмотрите возможность использовать PKey::PKey#sign_raw, PKey::PKey#verify_raw и PKey::PKey#verify_recover.

public? → true Показать исходный код

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

Возвращаемое значение всегда равно true, поскольку каждый закрытый ключ также является открытым ключом.

public_decrypt(string) → String Показать исходный код

public_decrypt(string, padding) → String

# File ext/openssl/lib/openssl/pkey.rb, line 396
def public_decrypt(string, padding = PKCS1_PADDING)
  n or raise OpenSSL::PKey::RSAError, "incomplete RSA"
  begin
    verify_recover(nil, string, {
      "rsa_padding_mode" => translate_padding_mode(padding),
    })
  rescue OpenSSL::PKey::PKeyError
    raise OpenSSL::PKey::RSAError, $!.message
  end
end

Расшифровывает string открытым ключом; данные должны быть зашифрованы закрытым ключом. padding по умолчанию равен PKCS1_PADDING, который считается небезопасным, но сохранен для обратной совместимости.

public_encrypt(string) → String Показать исходный код

public_encrypt(string, padding) → String

# File ext/openssl/lib/openssl/pkey.rb, line 418
def public_encrypt(data, padding = PKCS1_PADDING)
  n or raise OpenSSL::PKey::RSAError, "incomplete RSA"
  begin
    encrypt(data, {
      "rsa_padding_mode" => translate_padding_mode(padding),
    })
  rescue OpenSSL::PKey::PKeyError
    raise OpenSSL::PKey::RSAError, $!.message
  end
end

Зашифровывает string открытым ключом. padding по умолчанию равен PKCS1_PADDING. Этот режим считается небезопасным, но сохранен для обратной совместимости. Полученную зашифрованную строку можно расшифровать с помощью private_decrypt.

Устарел в версии 3.0. Вместо этого рассмотрите возможность использовать PKey::PKey#encrypt и PKey::PKey#decrypt.

public_key → rsanew Показать исходный код

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

Возвращает новый экземпляр RSA, содержащий только компоненты открытого ключа.

Этот метод предоставлен для обратной совместимости. В большинстве случаев вызывать его не требуется.

Чтобы сериализовать открытый ключ в кодировку PEM или DER в формате X.509 SubjectPublicKeyInfo, см. PKey#public_to_pem и PKey#public_to_der.

set_crt_params(dmp1, dmq1, iqmp) → self

Задает dmp1, dmq1, iqmp для экземпляра RSA. Они вычисляются соответственно как d mod (p - 1), d mod (q - 1) и q^(-1) mod p.

set_factors(p, q) → self

Задает p, q для экземпляра RSA.

set_key(n, e, d) → self

Задает n, e, d для экземпляра RSA.

sign_pss(digest, data, salt_length:, mgf1_hash:) → String Показать исходный код

static VALUE
ossl_rsa_sign_pss(int argc, VALUE *argv, VALUE self)
{
    VALUE digest, data, options, kwargs[2], signature;
    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_get_digestbyname(kwargs[1]);

    pkey = GetPrivPKeyPtr(self);
    buf_len = EVP_PKEY_size(pkey);
    md = ossl_evp_get_digestbyname(digest);
    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(eRSAError, NULL);
}

Подписывает data с помощью вероятностной схемы цифровой подписи (RSA-PSS) и возвращает вычисленную подпись.

При возникновении ошибки будет вызвано исключение RSAError.

Описание проверки подписи см. в verify_pss.

Параметры

digest: Значение типа String, содержащее имя алгоритма дайджеста сообщения.
data: Значение типа String. Данные для подписи.
salt_length: Длина соли в октетах. Зарезервированы два специальных значения: :digest означает длину дайджеста, а :max — максимально возможную длину для сочетания закрытого ключа и выбранного алгоритма дайджеста сообщения.
mgf1_hash: Алгоритм хеширования, используемый в MGF1 (поддерживаемой в настоящее время функции генерации маски (MGF)).

Пример

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

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

Сериализует закрытый или открытый ключ в кодировку DER.

Подробнее см. to_pem.

Вместо этого рассмотрите возможность использовать public_to_der или private_to_der.

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

Сериализует закрытый или открытый ключ в кодировку PEM.

Если ключ содержит только компоненты открытого ключа

Сериализует его в формате X.509 SubjectPublicKeyInfo. Параметры cipher и password игнорируются.

Ключ в кодировке PEM будет выглядеть так:

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

Если ключ содержит компоненты закрытого ключа и параметры не заданы

Сериализует его в формате PKCS #1 RSAPrivateKey.

Ключ в кодировке PEM будет выглядеть так:

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

Если ключ содержит компоненты закрытого ключа и заданы параметры cipher и password

Зашифрованный ключ в кодировке PEM будет выглядеть так:

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

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

Псевдоним для: export

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

Сериализует закрытый или открытый ключ в кодировку PEM.

Если ключ содержит только компоненты открытого ключа

Сериализует его в формате X.509 SubjectPublicKeyInfo. Параметры cipher и password игнорируются.

Ключ в кодировке PEM будет выглядеть так:

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

Если ключ содержит компоненты закрытого ключа и параметры не заданы

Сериализует его в формате PKCS #1 RSAPrivateKey.

Ключ в кодировке PEM будет выглядеть так:

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

Если ключ содержит компоненты закрытого ключа и заданы параметры cipher и password

Зашифрованный ключ в кодировке PEM будет выглядеть так:

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

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

Псевдоним для: export

verify_pss(digest, signature, data, salt_length:, mgf1_hash:) → true | false Показать исходный код

static VALUE
ossl_rsa_verify_pss(int argc, VALUE *argv, VALUE self)
{
    VALUE digest, signature, data, options, kwargs[2];
    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_get_digestbyname(kwargs[1]);

    GetPKey(self, pkey);
    md = ossl_evp_get_digestbyname(digest);
    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));

    switch (result) {
      case 0:
        ossl_clear_error();
        EVP_MD_CTX_free(md_ctx);
        return Qfalse;
      case 1:
        EVP_MD_CTX_free(md_ctx);
        return Qtrue;
      default:
        goto err;
    }

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

Проверяет data с помощью вероятностной схемы цифровой подписи (RSA-PSS).

Если подпись верна, возвращаемое значение — true, в противном случае — false. При возникновении ошибки будет вызвано исключение RSAError.

Описание операции подписания и пример кода см. в sign_pss.

Параметры

digest: Значение типа String, содержащее имя алгоритма дайджеста сообщения.
data: Значение типа String. Данные для подписи.
salt_length: Длина соли в октетах. Зарезервированы два специальных значения: :digest означает длину дайджеста, а :auto — автоматическое определение длины на основе подписи.
mgf1_hash: Алгоритм хеширования, используемый в MGF1.

Приватные методы экземпляра

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

# File ext/openssl/lib/openssl/pkey.rb, line 456
        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 OpenSSL::PKey::PKeyError, "unsupported padding mode"
  end
end

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