Class: OpenSSL::PKey::RSA

Inherits:
PKey
  • Object
show all
Includes:
Marshal
Defined in:
ext/openssl/ossl_pkey_rsa.c,
lib/openssl/pkey.rb,
ext/openssl/ossl_pkey_rsa.c

Overview

RSA is an asymmetric public key algorithm that has been formalized in RFC 3447. It is in widespread use in public key infrastructures (PKI) where certificates (cf. OpenSSL::X509::Certificate) often are issued on the basis of a public/private RSA key pair. RSA is used in a wide field of applications such as secure (symmetric) key exchange, e.g. when establishing a secure TLS/SSL connection. It is also used in various digital signature schemes.

Constant Summary collapse

PKCS1_PADDING = 
1
SSLV23_PADDING = 
2
NO_PADDING = 
3
PKCS1_OAEP_PADDING = 
4

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Marshal

#_dump, included

Methods inherited from PKey

#compare?, #decrypt, #derive, #encrypt, #inspect, #oid, #private_to_der, #private_to_pem, #public_to_der, #public_to_pem, #raw_private_key, #raw_public_key, #sign, #sign_raw, #to_text, #verify, #verify_raw, #verify_recover

Constructor Details

#new ⇒ Object #new(encoded_key[, password ]) ⇒ Object #new(encoded_key) { ... } ⇒ Object #new(size[, exponent]) ⇒ Object

Generates or loads an RSA keypair.

If called without arguments, creates a new instance with no key components set. They can be set individually by #set_key, #set_factors, and #set_crt_params. This form is not compatible with OpenSSL 3.0 or later.

If called with a String, tries to parse as DER or PEM encoding of an RSA key. Note that if password is not specified, but the key is encrypted with a password, OpenSSL will prompt for it. See also OpenSSL::PKey.read which can parse keys of any kind.

If called with a number, generates a new key pair. This form works as an alias of RSA.generate.

Examples:

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

Overloads:

  • #new(encoded_key) { ... } ⇒ Object

    Yields:



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 78

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

Class Method Details

.generate(size, exp = 0x10001, &blk) ⇒ Object

:call-seq:

RSA.generate(size, exponent = 65537) -> RSA

Generates an RSA keypair.

See also OpenSSL::PKey.generate_key.

size

The desired key size in bits.

exponent

An odd Integer, normally 3, 17, or 65537.



381
382
383
384
385
386
 
# File '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

.new(*args, &blk) ⇒ Object

Handle RSA.new(size, exponent) form here; new(str) and new() forms are handled by #initialize



390
391
392
393
394
395
396
 
# File 'lib/openssl/pkey.rb', line 390

def new(*args, &blk) # :nodoc:
  if args[0].is_a?(Integer)
    generate(*args, &blk)
  else
    super
  end
end

Instance Method Details

#export([cipher, password]) ⇒ PEM-format String #to_pem([cipher, password]) ⇒ PEM-format String #to_s([cipher, password]) ⇒ PEM-format String Also known as: to_pem, to_s

Serializes a private or public key to a PEM-encoding.

When the key contains public components only

Serializes it into an X.509 SubjectPublicKeyInfo. The parameters cipher and password are ignored.

A PEM-encoded key will look like:

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

Consider using #public_to_pem instead. This serializes the key into an X.509 SubjectPublicKeyInfo regardless of whether the key is a public key or a private key.

When the key contains private components, and no parameters are given

Serializes it into a PKCS #1 RSAPrivateKey.

A PEM-encoded key will look like:

-----BEGIN RSA PRIVATE KEY-----
[...]
-----END RSA PRIVATE KEY-----
When the key contains private components, and cipher and password are given

Serializes it into a PKCS #1 RSAPrivateKey and encrypts it in OpenSSL’s traditional PEM encryption format. cipher must be a cipher name understood by OpenSSL::Cipher.new or an instance of OpenSSL::Cipher.

An encrypted PEM-encoded key will look like:

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

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

Note that this format uses MD5 to derive the encryption key, and hence will not be available on FIPS-compliant systems.

This method is kept for compatibility. This should only be used when the PKCS #1 RSAPrivateKey format is required.

Consider using #public_to_pem (X.509 SubjectPublicKeyInfo) or #private_to_pem (PKCS #8 PrivateKeyInfo or EncryptedPrivateKeyInfo) instead.

Overloads:

  • #export([cipher, password]) ⇒ PEM-format String

    Returns:

    • (PEM-format String)
  • #to_pem([cipher, password]) ⇒ PEM-format String

    Returns:

    • (PEM-format String)
  • #to_s([cipher, password]) ⇒ PEM-format String

    Returns:

    • (PEM-format String) 


284
285
286
287
288
289
290
291
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 284

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

#initialize_copy(other) ⇒ Object

:nodoc:



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 147

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(ePKeyError, "ASN1_dup");

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

    return self;
}

#params ⇒ Object

:call-seq:

rsa.params -> hash

Stores all parameters of key to a Hash.

The hash has keys ‘n’, ‘e’, ‘d’, ‘p’, ‘q’, ‘dmp1’, ‘dmq1’, and ‘iqmp’.



363
364
365
366
367
 
# File '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

#private? ⇒ Boolean

Does this keypair contain a private key?

Returns:

  • (Boolean) 


201
202
203
204
205
206
207
208
209
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 201

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(data, padding = PKCS1_PADDING) ⇒ Object

:call-seq:

rsa.private_decrypt(string)          -> String
rsa.private_decrypt(string, padding) -> String

Decrypt string, which has been encrypted with the public key, with the private key. padding defaults to PKCS1_PADDING, which is known to be insecure but is kept for backwards compatibility.

Deprecated in version 3.0. Consider using PKey::PKey#encrypt and PKey::PKey#decrypt instead.



465
466
467
468
469
470
471
 
# File '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

#private_encrypt(string, padding = PKCS1_PADDING) ⇒ Object

:call-seq:

rsa.private_encrypt(string)          -> String
rsa.private_encrypt(string, padding) -> String

Encrypt string with the private key. padding defaults to PKCS1_PADDING, which is known to be insecure but is kept for backwards compatibility. The encrypted string output can be decrypted using #public_decrypt.

Deprecated in version 3.0. Consider using PKey::PKey#sign_raw and PKey::PKey#verify_raw, and PKey::PKey#verify_recover instead.



411
412
413
414
415
416
417
 
# File '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

#public? ⇒ true

The return value is always true since every private key is also a public key.

Returns:

  • (true) 


182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 182

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

#public_decrypt(string, padding = PKCS1_PADDING) ⇒ Object

:call-seq:

rsa.public_decrypt(string)          -> String
rsa.public_decrypt(string, padding) -> String

Decrypt string, which has been encrypted with the private key, with the public key. padding defaults to PKCS1_PADDING which is known to be insecure but is kept for backwards compatibility.

Deprecated in version 3.0. Consider using PKey::PKey#sign_raw and PKey::PKey#verify_raw, and PKey::PKey#verify_recover instead.



430
431
432
433
434
435
 
# File '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

#public_encrypt(data, padding = PKCS1_PADDING) ⇒ Object

:call-seq:

rsa.public_encrypt(string)          -> String
rsa.public_encrypt(string, padding) -> String

Encrypt string with the public key. padding defaults to PKCS1_PADDING, which is known to be insecure but is kept for backwards compatibility. The encrypted string output can be decrypted using #private_decrypt.

Deprecated in version 3.0. Consider using PKey::PKey#encrypt and PKey::PKey#decrypt instead.



448
449
450
451
452
453
 
# File '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

#public_key ⇒ Object

:call-seq:

rsa.public_key -> rsanew

Returns a new RSA instance that carries just the public key components.

This method is provided for backwards compatibility. In most cases, there is no need to call this method.

For the purpose of serializing the public key, to PEM or DER encoding of X.509 SubjectPublicKeyInfo format, check PKey#public_to_pem and PKey#public_to_der.



353
354
355
 
# File 'lib/openssl/pkey.rb', line 353

def public_key
  OpenSSL::PKey.read(public_to_der)
end

#set_crt_params(dmp1, dmq1, iqmp) ⇒ self

Sets dmp1, dmq1, iqmp for the RSA instance. They are calculated by d mod (p - 1), d mod (q - 1) and q^(-1) mod p respectively.

Returns:

  • (self)

#set_factors(p, q) ⇒ self

Sets p, q for the RSA instance.

Returns:

  • (self)

#set_key(n, e, d) ⇒ self

Sets n, e, d for the RSA instance.

Returns:

  • (self)

#sign_pss(digest, data, salt_length:, mgf1_hash:) ⇒ String

Signs data using the Probabilistic Signature Scheme (RSA-PSS) and returns the calculated signature.

PKeyError will be raised if an error occurs.

See #verify_pss for the verification operation.

Parameters

digest

A String containing the message digest algorithm name.

data

A String. The data to be signed.

salt_length

The length in octets of the salt. Two special values are reserved: :digest means the digest length, and :max means the maximum possible length for the combination of the private key and the selected message digest algorithm.

mgf1_hash

The hash algorithm used in MGF1 (the currently supported mask generation function (MGF)).

Example

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

Returns:

  • (String) 


348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 348

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

#to_der ⇒ DER-format String

Serializes a private or public key to a DER-encoding.

See #to_pem for details.

This method is kept for compatibility. This should only be used when the PKCS #1 RSAPrivateKey format is required.

Consider using #public_to_der or #private_to_der instead.

Returns:

  • (DER-format String) 


306
307
308
309
310
311
312
313
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 306

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

#verify_pss(digest, signature, data, salt_length:, mgf1_hash:) ⇒ Object

Verifies data using the Probabilistic Signature Scheme (RSA-PSS).

The return value is true if the signature is valid, false otherwise. PKeyError will be raised if an error occurs.

See #sign_pss for the signing operation and an example code.

Parameters

digest

A String containing the message digest algorithm name.

data

A String. The data to be signed.

salt_length

The length in octets of the salt. Two special values are reserved: :digest means the digest length, and :auto means automatically determining the length based on the signature.

mgf1_hash

The hash algorithm used in MGF1.



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
 
# File 'ext/openssl/ossl_pkey_rsa.c', line 435

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