From 0a2c888ac573413eaf0cde3d77e47b1fe1af7605 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Tue, 11 Oct 2016 12:04:48 -0500 Subject: [PATCH 1/9] Add RSA sign_pss() and verify_pss() methods **Why**: Supports Probabilistic Signature Scheme for RSA key signing. --- ext/openssl/ossl_pkey_rsa.c | 150 ++++++++++++++++++++++++++++++++++++ test/test_pkey_rsa.rb | 11 +++ 2 files changed, 161 insertions(+) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index cea228d6d..9a0966998 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -626,6 +626,153 @@ ossl_rsa_to_public_key(VALUE self) return obj; } +#if (OPENSSL_VERSION_NUMBER >= 0x10000000) +/* + * call-seq: + * rsa.sign_pss -> String + * + * Probabilistic Signature Scheme for RSA sign(). + * + * To sign the +String+ +data+, +digest+, an instance of OpenSSL::Digest, must + * be provided. The return value is again a +String+ containing the signature. + * A PKeyError is raised should errors occur. + * Any previous state of the +Digest+ instance is irrelevant to the signature + * outcome, the digest instance is reset to its initial state during the + * operation. + * + * == Example + * data = 'Sign me!' + * digest = OpenSSL::Digest::SHA256.new + * pkey = OpenSSL::PKey::RSA.new(2048) + * signature = pkey.sign(digest, data) + */ +static VALUE +ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) +{ + EVP_PKEY *pkey; + EVP_PKEY_CTX *pkey_ctx; + const EVP_MD *md; + EVP_MD_CTX *md_ctx; + size_t buf_len; + VALUE signature; + int result; + + pkey = GetPrivPKeyPtr(self); + md = GetDigestPtr(digest); + StringValue(data); + signature = rb_str_new(0, EVP_PKEY_size(pkey)+16); + + md_ctx = EVP_MD_CTX_new(); + if (!md_ctx) + ossl_raise(ePKeyError, "EVP_MD_CTX_new"); + + pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); + if (!pkey_ctx) + ossl_raise(ePKeyError, "EVP_PKEY_CTX_new"); + + if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) + ossl_raise(ePKeyError, "EVP_DigestSignInit"); + + EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); + + if (EVP_DigestSignUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) + ossl_raise(ePKeyError, "EVP_DigestSignUpdate"); + + result = EVP_DigestSignFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), &buf_len); + + EVP_MD_CTX_destroy(md_ctx); + + if (!result) + ossl_raise(ePKeyError, NULL); + + assert((long)buf_len <= RSTRING_LEN(signature)); + rb_str_set_len(signature, buf_len); + + return signature; +} + +/* + * call-seq: + * pkey.verify_pss(digest, signature, data) -> String + * + * Probabilistic Signature Scheme for RSA verify(). + * + * To verify the +String+ +signature+, +digest+, an instance of + * OpenSSL::Digest, must be provided to re-compute the message digest of the + * original +data+, also a +String+. The return value is +true+ if the + * signature is valid, +false+ otherwise. A PKeyError is raised should errors + * occur. + * Any previous state of the +Digest+ instance is irrelevant to the validation + * outcome, the digest instance is reset to its initial state during the + * operation. + * + * == Example + * data = 'Sign me!' + * digest = OpenSSL::Digest::SHA256.new + * pkey = OpenSSL::PKey::RSA.new(2048) + * signature = pkey.sign(digest, data) + * pub_key = pkey.public_key + * puts pub_key.verify(digest, signature, data) # => true + */ +static VALUE +ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) +{ + EVP_PKEY *pkey; + EVP_PKEY_CTX *pkey_ctx; + const EVP_MD *md; + EVP_MD_CTX *md_ctx; + int result; + void *pkey_ptr; + const BIGNUM *n, *e; + + GetPKey(self, pkey); + md = GetDigestPtr(digest); + StringValue(signature); + StringValue(data); + + if (EVP_PKEY_missing_parameters(pkey)) + ossl_raise(ePKeyError, "parameters missing"); + + pkey_ptr = EVP_PKEY_get0(pkey); + if (EVP_PKEY_base_id(pkey) != EVP_PKEY_RSA) + ossl_raise(ePKeyError, "key must be RSA"); + + RSA_get0_key(pkey_ptr, &n, &e, NULL); + if (!(n && e)) + ossl_raise(ePKeyError, "missing public RSA key"); + + md_ctx = EVP_MD_CTX_new(); + if (!md_ctx) + ossl_raise(ePKeyError, "EVP_MD_CTX_new"); + + pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); + if (!pkey_ctx) + ossl_raise(ePKeyError, "EVP_PKEY_CTX_new"); + + if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) + ossl_raise(ePKeyError, "EVP_DigestVerifyInit"); + + EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); + + if (EVP_DigestVerifyUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) + ossl_raise(ePKeyError, "EVP_DigestVerifyUpdate"); + + result = EVP_DigestVerifyFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), RSTRING_LENINT(signature)); + EVP_MD_CTX_destroy(md_ctx); + + switch (result) { + case 0: + ossl_clear_error(); + return Qfalse; + case 1: + return Qtrue; + default: + ossl_raise(ePKeyError, NULL); + } + return Qnil; /* dummy */ +} +#endif + /* * TODO: Test me @@ -744,6 +891,9 @@ Init_ossl_rsa(void) rb_define_method(cRSA, "set_factors", ossl_rsa_set_factors, 2); rb_define_method(cRSA, "set_crt_params", ossl_rsa_set_crt_params, 3); + rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 2); + rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 3); + rb_define_method(cRSA, "params", ossl_rsa_get_params, 0); DefRSAConst(PKCS1_PADDING); diff --git a/test/test_pkey_rsa.rb b/test/test_pkey_rsa.rb index b24f1d550..a476cde12 100644 --- a/test/test_pkey_rsa.rb +++ b/test/test_pkey_rsa.rb @@ -7,6 +7,17 @@ class OpenSSL::TestPKeyRSA < OpenSSL::PKeyTestCase RSA1024 = OpenSSL::TestUtils::TEST_KEY_RSA1024 + def test_sign_verify_pss + key = OpenSSL::PKey::RSA.new(512, 3) + digest = OpenSSL::Digest::SHA1.new + data = "Sign me!" + invalid_data = "Sign me?" + + signature = key.sign_pss(digest, data) + assert_equal(true, key.verify_pss(digest, signature, data)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data)) + end + def test_padding key = OpenSSL::PKey::RSA.new(512, 3) From 37bf8ce138b4eff9bd3e96e0e27f144aa7521755 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Tue, 11 Oct 2016 12:09:34 -0500 Subject: [PATCH 2/9] Fix *_pss documentation --- ext/openssl/ossl_pkey_rsa.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index 9a0966998..c33847b93 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -644,7 +644,7 @@ ossl_rsa_to_public_key(VALUE self) * data = 'Sign me!' * digest = OpenSSL::Digest::SHA256.new * pkey = OpenSSL::PKey::RSA.new(2048) - * signature = pkey.sign(digest, data) + * signature = pkey.sign_pss(digest, data) */ static VALUE ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) @@ -712,7 +712,7 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) * pkey = OpenSSL::PKey::RSA.new(2048) * signature = pkey.sign(digest, data) * pub_key = pkey.public_key - * puts pub_key.verify(digest, signature, data) # => true + * puts pub_key.verify_pss(digest, signature, data) # => true */ static VALUE ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) From ab1793a055810ef0922dee5e1e9ffe0831bfe2a8 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Fri, 14 Oct 2016 11:14:40 -0500 Subject: [PATCH 3/9] refactor to avoid leaks, other review feedback --- ext/openssl/ossl_pkey_rsa.c | 101 ++++++++++++++++++++++-------------- 1 file changed, 61 insertions(+), 40 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index c33847b93..0c684f0d8 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -629,12 +629,13 @@ ossl_rsa_to_public_key(VALUE self) #if (OPENSSL_VERSION_NUMBER >= 0x10000000) /* * call-seq: - * rsa.sign_pss -> String + * rsa.sign_pss(digest, data) -> String * * Probabilistic Signature Scheme for RSA sign(). * - * To sign the +String+ +data+, +digest+, an instance of OpenSSL::Digest, must - * be provided. The return value is again a +String+ containing the signature. + * To sign the +String+ +data+, +digest+ must be provided. + * +digest+ must be a OpenSSL::Digest instance or +String+ like "SHA1". + * The return value is again a +String+ containing the signature. * A PKeyError is raised should errors occur. * Any previous state of the +Digest+ instance is irrelevant to the signature * outcome, the digest instance is reset to its initial state during the @@ -655,39 +656,50 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) EVP_MD_CTX *md_ctx; size_t buf_len; VALUE signature; - int result; + int error; + + error = 0; pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); StringValue(data); - signature = rb_str_new(0, EVP_PKEY_size(pkey)+16); + signature = rb_str_new(0, EVP_PKEY_size(pkey)); md_ctx = EVP_MD_CTX_new(); if (!md_ctx) ossl_raise(ePKeyError, "EVP_MD_CTX_new"); pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); - if (!pkey_ctx) - ossl_raise(ePKeyError, "EVP_PKEY_CTX_new"); + if (!pkey_ctx) { + error = 1; + goto err; + } - if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) - ossl_raise(ePKeyError, "EVP_DigestSignInit"); + if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) { + error = 2; + goto err; + } EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); - if (EVP_DigestSignUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) - ossl_raise(ePKeyError, "EVP_DigestSignUpdate"); - - result = EVP_DigestSignFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), &buf_len); - - EVP_MD_CTX_destroy(md_ctx); + if (EVP_DigestSignUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) { + error = 3; + goto err; + } - if (!result) - ossl_raise(ePKeyError, NULL); + if (EVP_DigestSignFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), &buf_len) != 1) { + error = 4; + goto err; + } - assert((long)buf_len <= RSTRING_LEN(signature)); rb_str_set_len(signature, buf_len); + err: + EVP_MD_CTX_destroy(md_ctx); + if (error) { + ossl_raise(ePKeyError, NULL); + } + return signature; } @@ -697,9 +709,10 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) * * Probabilistic Signature Scheme for RSA verify(). * - * To verify the +String+ +signature+, +digest+, an instance of - * OpenSSL::Digest, must be provided to re-compute the message digest of the - * original +data+, also a +String+. The return value is +true+ if the + * To verify the +String+ +signature+, +digest+ and +data+ must be provided + * to re-compute the message digest. See +sign_pss+ for details about + * +digest+ and +data+. + * The return value is +true+ if the * signature is valid, +false+ otherwise. A PKeyError is raised should errors * occur. * Any previous state of the +Digest+ instance is irrelevant to the validation @@ -721,44 +734,52 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) EVP_PKEY_CTX *pkey_ctx; const EVP_MD *md; EVP_MD_CTX *md_ctx; - int result; + int result, error; void *pkey_ptr; const BIGNUM *n, *e; - GetPKey(self, pkey); + error = 0; + + GetPKeyRSA(self, pkey); md = GetDigestPtr(digest); StringValue(signature); StringValue(data); - if (EVP_PKEY_missing_parameters(pkey)) - ossl_raise(ePKeyError, "parameters missing"); - pkey_ptr = EVP_PKEY_get0(pkey); - if (EVP_PKEY_base_id(pkey) != EVP_PKEY_RSA) - ossl_raise(ePKeyError, "key must be RSA"); - RSA_get0_key(pkey_ptr, &n, &e, NULL); if (!(n && e)) ossl_raise(ePKeyError, "missing public RSA key"); md_ctx = EVP_MD_CTX_new(); - if (!md_ctx) + if (!md_ctx) { ossl_raise(ePKeyError, "EVP_MD_CTX_new"); + } pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); - if (!pkey_ctx) - ossl_raise(ePKeyError, "EVP_PKEY_CTX_new"); + if (!pkey_ctx) { + error = 1; + goto err; + } - if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) - ossl_raise(ePKeyError, "EVP_DigestVerifyInit"); + if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) { + error = 2; + goto err; + } EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); - if (EVP_DigestVerifyUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) - ossl_raise(ePKeyError, "EVP_DigestVerifyUpdate"); + if (EVP_DigestVerifyUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) { + error = 3; + goto err; + } result = EVP_DigestVerifyFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), RSTRING_LENINT(signature)); + + err: EVP_MD_CTX_destroy(md_ctx); + if (error) { + ossl_raise(ePKeyError, NULL); + } switch (result) { case 0: @@ -769,7 +790,6 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) default: ossl_raise(ePKeyError, NULL); } - return Qnil; /* dummy */ } #endif @@ -878,6 +898,10 @@ Init_ossl_rsa(void) rb_define_method(cRSA, "public_decrypt", ossl_rsa_public_decrypt, -1); rb_define_method(cRSA, "private_encrypt", ossl_rsa_private_encrypt, -1); rb_define_method(cRSA, "private_decrypt", ossl_rsa_private_decrypt, -1); +#if (OPENSSL_VERSION_NUMBER >= 0x10000000) + rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 2); + rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 3); +#endif DEF_OSSL_PKEY_BN(cRSA, rsa, n); DEF_OSSL_PKEY_BN(cRSA, rsa, e); @@ -891,9 +915,6 @@ Init_ossl_rsa(void) rb_define_method(cRSA, "set_factors", ossl_rsa_set_factors, 2); rb_define_method(cRSA, "set_crt_params", ossl_rsa_set_crt_params, 3); - rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 2); - rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 3); - rb_define_method(cRSA, "params", ossl_rsa_get_params, 0); DefRSAConst(PKCS1_PADDING); From f9eef35d5bc20b75d2514c9746887abcc72a7a97 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Wed, 19 Oct 2016 12:04:31 -0500 Subject: [PATCH 4/9] review feedback, mostly whitespace indentation fixes --- ext/openssl/ossl_pkey_rsa.c | 108 ++++++++++++++---------------------- 1 file changed, 43 insertions(+), 65 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index 0c684f0d8..aff9822d9 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -656,9 +656,6 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) EVP_MD_CTX *md_ctx; size_t buf_len; VALUE signature; - int error; - - error = 0; pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); @@ -667,40 +664,31 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) md_ctx = EVP_MD_CTX_new(); if (!md_ctx) - ossl_raise(ePKeyError, "EVP_MD_CTX_new"); + ossl_raise(eRSAError, "EVP_MD_CTX_new"); - pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); - if (!pkey_ctx) { - error = 1; - goto err; - } + if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) + goto err; - if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) { - error = 2; - goto err; - } + if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1) + goto err; - EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); + // EVP_PKEY_CTX_set_rsa_pss_saltlen + // - if (EVP_DigestSignUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) { - error = 3; - 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) { - error = 4; - goto err; - } + if (EVP_DigestSignFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), &buf_len) != 1) + goto err; rb_str_set_len(signature, buf_len); - err: - EVP_MD_CTX_destroy(md_ctx); - if (error) { - ossl_raise(ePKeyError, NULL); - } - + EVP_MD_CTX_free(md_ctx); return signature; + + err: + EVP_MD_CTX_free(md_ctx); + ossl_raise(eRSAError, NULL); } /* @@ -734,62 +722,52 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) EVP_PKEY_CTX *pkey_ctx; const EVP_MD *md; EVP_MD_CTX *md_ctx; - int result, error; - void *pkey_ptr; - const BIGNUM *n, *e; - - error = 0; + int result; + RSA *rsa; + const BIGNUM *rsa_n; GetPKeyRSA(self, pkey); md = GetDigestPtr(digest); StringValue(signature); StringValue(data); - pkey_ptr = EVP_PKEY_get0(pkey); - RSA_get0_key(pkey_ptr, &n, &e, NULL); - if (!(n && e)) - ossl_raise(ePKeyError, "missing public RSA key"); + GetRSA(self, rsa); + RSA_get0_key(rsa, &rsa_n, NULL, NULL); + if (!rsa_n) + ossl_raise(eRSAError, "incomplete RSA"); md_ctx = EVP_MD_CTX_new(); - if (!md_ctx) { - ossl_raise(ePKeyError, "EVP_MD_CTX_new"); - } + if (!md_ctx) + ossl_raise(eRSAError, "EVP_MD_CTX_new"); - pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL); - if (!pkey_ctx) { - error = 1; - goto err; - } + if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) + goto err; - if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) { - error = 2; - goto err; - } + if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1) + goto err; - EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING); - - if (EVP_DigestVerifyUpdate(md_ctx, RSTRING_PTR(data), RSTRING_LEN(data)) != 1) { - error = 3; - 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_LENINT(signature)); - err: - EVP_MD_CTX_destroy(md_ctx); - if (error) { - ossl_raise(ePKeyError, NULL); - } - + switch (result) { case 0: - ossl_clear_error(); - return Qfalse; + ossl_clear_error(); + EVP_MD_CTX_free(md_ctx); + return Qfalse; case 1: - return Qtrue; + EVP_MD_CTX_free(md_ctx); + return Qtrue; default: - ossl_raise(ePKeyError, NULL); + goto err; } + + err: + EVP_MD_CTX_free(md_ctx); + ossl_raise(eRSAError, NULL); + } #endif From f1f835524cc562842a80444562c1d5433a3fa08c Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Wed, 19 Oct 2016 14:56:40 -0500 Subject: [PATCH 5/9] add salt_len and hash_alg arguments to {sign|verify}_pss --- ext/openssl/ossl_pkey_rsa.c | 57 ++++++++++++++++++++++++++----------- test/test_pkey_rsa.rb | 8 ++++-- 2 files changed, 45 insertions(+), 20 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index aff9822d9..7b401baa5 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -626,17 +626,22 @@ ossl_rsa_to_public_key(VALUE self) return obj; } -#if (OPENSSL_VERSION_NUMBER >= 0x10000000) +#if (OPENSSL_VERSION_NUMBER >= 0x1000100f) /* * call-seq: - * rsa.sign_pss(digest, data) -> String + * rsa.sign_pss(digest, data, salt_len, hash_alg) -> String * * Probabilistic Signature Scheme for RSA sign(). * * To sign the +String+ +data+, +digest+ must be provided. * +digest+ must be a OpenSSL::Digest instance or +String+ like "SHA1". + * + * The +Integer+ +salt_len+ should be the salt length to use. + * + * The +String+ +hash_alg+ should be the hash algorithm used in MGF. + * * The return value is again a +String+ containing the signature. - * A PKeyError is raised should errors occur. + * A RSAError is raised should errors occur. * Any previous state of the +Digest+ instance is irrelevant to the signature * outcome, the digest instance is reset to its initial state during the * operation. @@ -645,20 +650,24 @@ ossl_rsa_to_public_key(VALUE self) * data = 'Sign me!' * digest = OpenSSL::Digest::SHA256.new * pkey = OpenSSL::PKey::RSA.new(2048) - * signature = pkey.sign_pss(digest, data) + * signature = pkey.sign_pss(digest, data, 20, 'SHA256') */ static VALUE -ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) +ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE hash_alg) { EVP_PKEY *pkey; EVP_PKEY_CTX *pkey_ctx; - const EVP_MD *md; + const EVP_MD *md, *mgf1md; EVP_MD_CTX *md_ctx; size_t buf_len; VALUE signature; + if (!RB_INTEGER_TYPE_P(saltlen)) + ossl_raise(eRSAError, "bad salt_len value"); + pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); + mgf1md = GetDigestPtr(hash_alg); StringValue(data); signature = rb_str_new(0, EVP_PKEY_size(pkey)); @@ -672,8 +681,11 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1) goto err; - // EVP_PKEY_CTX_set_rsa_pss_saltlen - // + if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, NUM2INT(saltlen)) != 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; @@ -693,13 +705,18 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) /* * call-seq: - * pkey.verify_pss(digest, signature, data) -> String + * pkey.verify_pss(digest, signature, data, salt_len, hash_alg) -> String * * Probabilistic Signature Scheme for RSA verify(). * * To verify the +String+ +signature+, +digest+ and +data+ must be provided * to re-compute the message digest. See +sign_pss+ for details about * +digest+ and +data+. + * + * The +Integer+ +salt_len+ should be the salt length to use. + * + * The +String+ +hash_alg+ should be the hash algorithm used in MGF. + * * The return value is +true+ if the * signature is valid, +false+ otherwise. A PKeyError is raised should errors * occur. @@ -711,16 +728,16 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data) * data = 'Sign me!' * digest = OpenSSL::Digest::SHA256.new * pkey = OpenSSL::PKey::RSA.new(2048) - * signature = pkey.sign(digest, data) + * signature = pkey.sign_pss(digest, data, 20, 'SHA256') * pub_key = pkey.public_key - * puts pub_key.verify_pss(digest, signature, data) # => true + * puts pub_key.verify_pss(digest, signature, data, 20, 'SHA256') # => true */ static VALUE -ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) +ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE saltlen, VALUE hash_alg) { EVP_PKEY *pkey; EVP_PKEY_CTX *pkey_ctx; - const EVP_MD *md; + const EVP_MD *md, *mgf1md; EVP_MD_CTX *md_ctx; int result; RSA *rsa; @@ -728,6 +745,7 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) GetPKeyRSA(self, pkey); md = GetDigestPtr(digest); + mgf1md = GetDigestPtr(hash_alg); StringValue(signature); StringValue(data); @@ -746,12 +764,17 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data) 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, NUM2INT(saltlen)) != 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_LENINT(signature)); - switch (result) { case 0: ossl_clear_error(); @@ -876,9 +899,9 @@ Init_ossl_rsa(void) rb_define_method(cRSA, "public_decrypt", ossl_rsa_public_decrypt, -1); rb_define_method(cRSA, "private_encrypt", ossl_rsa_private_encrypt, -1); rb_define_method(cRSA, "private_decrypt", ossl_rsa_private_decrypt, -1); -#if (OPENSSL_VERSION_NUMBER >= 0x10000000) - rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 2); - rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 3); +#if (OPENSSL_VERSION_NUMBER >= 0x1000100f) + rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 4); + rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 5); #endif DEF_OSSL_PKEY_BN(cRSA, rsa, n); diff --git a/test/test_pkey_rsa.rb b/test/test_pkey_rsa.rb index a476cde12..537799bf3 100644 --- a/test/test_pkey_rsa.rb +++ b/test/test_pkey_rsa.rb @@ -10,12 +10,14 @@ class OpenSSL::TestPKeyRSA < OpenSSL::PKeyTestCase def test_sign_verify_pss key = OpenSSL::PKey::RSA.new(512, 3) digest = OpenSSL::Digest::SHA1.new + salt_len = 20 + hash_alg = 'SHA1' data = "Sign me!" invalid_data = "Sign me?" - signature = key.sign_pss(digest, data) - assert_equal(true, key.verify_pss(digest, signature, data)) - assert_equal(false, key.verify_pss(digest, signature, invalid_data)) + signature = key.sign_pss(digest, data, salt_len, hash_alg) + assert_equal(true, key.verify_pss(digest, signature, data, salt_len, hash_alg)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_len, hash_alg)) end def test_padding From fd375426a95fe0e9c5e2a3160beebb4a71895dc8 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Thu, 20 Oct 2016 10:13:41 -0500 Subject: [PATCH 6/9] review updates --- ext/openssl/ossl_pkey_rsa.c | 26 +++++++++++++++----------- test/test_pkey_rsa.rb | 22 ++++++++++++---------- 2 files changed, 27 insertions(+), 21 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index 7b401baa5..8b3457f6d 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -638,7 +638,8 @@ ossl_rsa_to_public_key(VALUE self) * * The +Integer+ +salt_len+ should be the salt length to use. * - * The +String+ +hash_alg+ should be the hash algorithm used in MGF. + * The +String+ +hash_alg+ should be the hash algorithm used in MGF1 + * (the currently supported mask generation function (MGF)). * * The return value is again a +String+ containing the signature. * A RSAError is raised should errors occur. @@ -660,20 +661,20 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has const EVP_MD *md, *mgf1md; EVP_MD_CTX *md_ctx; size_t buf_len; + int salt_len; VALUE signature; - if (!RB_INTEGER_TYPE_P(saltlen)) - ossl_raise(eRSAError, "bad salt_len value"); - + salt_len = NUM2INT(saltlen); pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); mgf1md = GetDigestPtr(hash_alg); StringValue(data); signature = rb_str_new(0, EVP_PKEY_size(pkey)); + buf_len = EVP_PKEY_size(pkey); md_ctx = EVP_MD_CTX_new(); if (!md_ctx) - ossl_raise(eRSAError, "EVP_MD_CTX_new"); + goto err; if (EVP_DigestSignInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) goto err; @@ -681,7 +682,7 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has 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, NUM2INT(saltlen)) != 1) + 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) @@ -715,7 +716,8 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has * * The +Integer+ +salt_len+ should be the salt length to use. * - * The +String+ +hash_alg+ should be the hash algorithm used in MGF. + * The +String+ +hash_alg+ should be the hash algorithm used in MGF1 + * (the currently supported mask generation function (MGF)). * * The return value is +true+ if the * signature is valid, +false+ otherwise. A PKeyError is raised should errors @@ -739,10 +741,12 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE EVP_PKEY_CTX *pkey_ctx; const EVP_MD *md, *mgf1md; EVP_MD_CTX *md_ctx; - int result; + int result, salt_len, sig_len; RSA *rsa; const BIGNUM *rsa_n; + salt_len = NUM2INT(saltlen); + sig_len = RSTRING_LENINT(signature); GetPKeyRSA(self, pkey); md = GetDigestPtr(digest); mgf1md = GetDigestPtr(hash_alg); @@ -756,7 +760,7 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE md_ctx = EVP_MD_CTX_new(); if (!md_ctx) - ossl_raise(eRSAError, "EVP_MD_CTX_new"); + goto err; if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, md, NULL, pkey) != 1) goto err; @@ -764,7 +768,7 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE 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, NUM2INT(saltlen)) != 1) + 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) @@ -773,7 +777,7 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE 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_LENINT(signature)); + result = EVP_DigestVerifyFinal(md_ctx, (unsigned char *)RSTRING_PTR(signature), sig_len); switch (result) { case 0: diff --git a/test/test_pkey_rsa.rb b/test/test_pkey_rsa.rb index 537799bf3..9dd086c4e 100644 --- a/test/test_pkey_rsa.rb +++ b/test/test_pkey_rsa.rb @@ -8,16 +8,18 @@ class OpenSSL::TestPKeyRSA < OpenSSL::PKeyTestCase RSA1024 = OpenSSL::TestUtils::TEST_KEY_RSA1024 def test_sign_verify_pss - key = OpenSSL::PKey::RSA.new(512, 3) - digest = OpenSSL::Digest::SHA1.new - salt_len = 20 - hash_alg = 'SHA1' - data = "Sign me!" - invalid_data = "Sign me?" - - signature = key.sign_pss(digest, data, salt_len, hash_alg) - assert_equal(true, key.verify_pss(digest, signature, data, salt_len, hash_alg)) - assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_len, hash_alg)) + if OpenSSL::OPENSSL_VERSION_NUMBER > 0x1000100f + key = OpenSSL::PKey::RSA.new(512, 3) + digest = OpenSSL::Digest::SHA1.new + salt_len = 20 + hash_alg = 'SHA1' + data = "Sign me!" + invalid_data = "Sign me?" + + signature = key.sign_pss(digest, data, salt_len, hash_alg) + assert_equal(true, key.verify_pss(digest, signature, data, salt_len, hash_alg)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_len, hash_alg)) + end end def test_padding From 36f8ca700b933a6b0b871f0ec09054aff592b2a7 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Wed, 16 Nov 2016 09:27:52 -0600 Subject: [PATCH 7/9] update docs to reflect named args --- ext/openssl/ossl_pkey_rsa.c | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index 8b3457f6d..c70537b1b 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -629,16 +629,18 @@ ossl_rsa_to_public_key(VALUE self) #if (OPENSSL_VERSION_NUMBER >= 0x1000100f) /* * call-seq: - * rsa.sign_pss(digest, data, salt_len, hash_alg) -> String + * rsa.sign_pss(digest, data, options) -> String * * Probabilistic Signature Scheme for RSA sign(). * * To sign the +String+ +data+, +digest+ must be provided. * +digest+ must be a OpenSSL::Digest instance or +String+ like "SHA1". * - * The +Integer+ +salt_len+ should be the salt length to use. + * The +Hash+ +options+ supports two key/value pairs: * - * The +String+ +hash_alg+ should be the hash algorithm used in MGF1 + * The +Integer+ +salt_length+ should be the salt length to use. + * + * The +String+ +mgf1_hash+ should be the hash algorithm used in MGF1 * (the currently supported mask generation function (MGF)). * * The return value is again a +String+ containing the signature. @@ -651,10 +653,10 @@ ossl_rsa_to_public_key(VALUE self) * data = 'Sign me!' * digest = OpenSSL::Digest::SHA256.new * pkey = OpenSSL::PKey::RSA.new(2048) - * signature = pkey.sign_pss(digest, data, 20, 'SHA256') + * signature = pkey.sign_pss(digest, data, salt_length: 20, mgf1_hash: 'SHA256') */ static VALUE -ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE hash_alg) +ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE mgf1_hash) { EVP_PKEY *pkey; EVP_PKEY_CTX *pkey_ctx; @@ -667,7 +669,7 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has salt_len = NUM2INT(saltlen); pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); - mgf1md = GetDigestPtr(hash_alg); + mgf1md = GetDigestPtr(mgf1_hash); StringValue(data); signature = rb_str_new(0, EVP_PKEY_size(pkey)); buf_len = EVP_PKEY_size(pkey); @@ -706,7 +708,7 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has /* * call-seq: - * pkey.verify_pss(digest, signature, data, salt_len, hash_alg) -> String + * pkey.verify_pss(digest, signature, data, options) -> String * * Probabilistic Signature Scheme for RSA verify(). * @@ -714,10 +716,14 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has * to re-compute the message digest. See +sign_pss+ for details about * +digest+ and +data+. * - * The +Integer+ +salt_len+ should be the salt length to use. + * The +Hash+ +options+ supports two key/value pairs: * - * The +String+ +hash_alg+ should be the hash algorithm used in MGF1 - * (the currently supported mask generation function (MGF)). + * The +Integer+ +salt_length+ should be the salt length to use. Must be the same value + * used in sign_pss(). + * + * The +String+ +mgf1_hash+ should be the hash algorithm used in MGF1 + * (the currently supported mask generation function (MGF)). Must be the same value + * used in sign_pss(). * * The return value is +true+ if the * signature is valid, +false+ otherwise. A PKeyError is raised should errors @@ -730,12 +736,12 @@ ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE has * data = 'Sign me!' * digest = OpenSSL::Digest::SHA256.new * pkey = OpenSSL::PKey::RSA.new(2048) - * signature = pkey.sign_pss(digest, data, 20, 'SHA256') + * signature = pkey.sign_pss(digest, data, salt_length: 20, mgf1_hash: 'SHA256') * pub_key = pkey.public_key - * puts pub_key.verify_pss(digest, signature, data, 20, 'SHA256') # => true + * puts pub_key.verify_pss(digest, signature, data, salt_length: 20, mgf1_hash: 'SHA256') # => true */ static VALUE -ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE saltlen, VALUE hash_alg) +ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE saltlen, VALUE mgf1_hash) { EVP_PKEY *pkey; EVP_PKEY_CTX *pkey_ctx; @@ -749,7 +755,7 @@ ossl_rsa_verify_pss(VALUE self, VALUE digest, VALUE signature, VALUE data, VALUE sig_len = RSTRING_LENINT(signature); GetPKeyRSA(self, pkey); md = GetDigestPtr(digest); - mgf1md = GetDigestPtr(hash_alg); + mgf1md = GetDigestPtr(mgf1_hash); StringValue(signature); StringValue(data); From eabbca7bd3833f18dcfc0c6a3ca9989a25c83967 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Wed, 16 Nov 2016 09:58:06 -0600 Subject: [PATCH 8/9] add tests for pss --- test/test_pkey_rsa.rb | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/test/test_pkey_rsa.rb b/test/test_pkey_rsa.rb index 9dd086c4e..16f71a26a 100644 --- a/test/test_pkey_rsa.rb +++ b/test/test_pkey_rsa.rb @@ -13,12 +13,37 @@ def test_sign_verify_pss digest = OpenSSL::Digest::SHA1.new salt_len = 20 hash_alg = 'SHA1' + options = { salt_length: salt_len, mgf1_hash: hash_alg } data = "Sign me!" invalid_data = "Sign me?" - signature = key.sign_pss(digest, data, salt_len, hash_alg) - assert_equal(true, key.verify_pss(digest, signature, data, salt_len, hash_alg)) - assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_len, hash_alg)) + signature = key.sign_pss(digest, data, salt_length: salt_len, mgf1_hash: hash_alg) + assert_equal(true, key.verify_pss(digest, signature, data, salt_length: salt_len, mgf1_hash: hash_alg)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_length: salt_len, mgf1_hash: hash_alg)) + + signature = key.sign_ss(digest, data, salt_length: salt_len) + assert_equal(true, key.verify_pss(digest, signature, data, salt_length: salt_len)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_length: salt_len)) + + signature = key.sign_ss(digest, data, mgf1_hash: hash_alg) + assert_equal(true, key.verify_pss(digest, signature, data, mgf1_hash: hash_alg)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, mgf1_hash: hash_alg)) + + signature = key.sign_ss(digest, data) + assert_equal(true, key.verify_pss(digest, signature, data)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data)) + + signature = key.sign_ss(digest, data, options) + assert_equal(true, key.verify_pss(digest, signature, data, options)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, options)) + + signature = key.sign_ss(digest, data, salt_length: :digest_length) + assert_equal(true, key.verify_pss(digest, signature, data, salt_length: :digest_length)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_length: :digest_length)) + + signature = key.sign_ss(digest, data, salt_length: :max_length) + assert_equal(true, key.verify_pss(digest, signature, data, salt_length: :max_length)) + assert_equal(false, key.verify_pss(digest, signature, invalid_data, salt_length: :max_length)) end end From 542e0c70c87aeff37d30fc34fca9175a7215eb29 Mon Sep 17 00:00:00 2001 From: Peter Karman Date: Tue, 9 May 2017 13:50:21 -0500 Subject: [PATCH 9/9] WIP variadic arguments --- ext/openssl/ossl_pkey_rsa.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/ext/openssl/ossl_pkey_rsa.c b/ext/openssl/ossl_pkey_rsa.c index c70537b1b..f143d93b9 100644 --- a/ext/openssl/ossl_pkey_rsa.c +++ b/ext/openssl/ossl_pkey_rsa.c @@ -639,6 +639,10 @@ ossl_rsa_to_public_key(VALUE self) * The +Hash+ +options+ supports two key/value pairs: * * The +Integer+ +salt_length+ should be the salt length to use. + * Two special values are reserved: -1 means use the digest length, and + * -2 means use the maximum possible length. If not specified, a default + * value of -2 is assumed. The symbols +:digest_length+ and +:max_length+ + * may be used instead. * * The +String+ +mgf1_hash+ should be the hash algorithm used in MGF1 * (the currently supported mask generation function (MGF)). @@ -656,16 +660,29 @@ ossl_rsa_to_public_key(VALUE self) * signature = pkey.sign_pss(digest, data, salt_length: 20, mgf1_hash: 'SHA256') */ static VALUE -ossl_rsa_sign_pss(VALUE self, VALUE digest, VALUE data, VALUE saltlen, VALUE mgf1_hash) +ossl_rsa_sign_pss(int argc, VALUE *argv, VALUE self) { + VALUE digest, data, options; + const ID options_table[] = {saltlen, mgf1_hash}; + VALUE kwvals[sizeof(options_table) / sizeof(*options_table)]; 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; + int salt_len, n_args; VALUE signature; + n_args = rb_scan_args(argc, argv, "21:", &digest, &data, &options); + if (n_args == 3) + rb_get_kwargs(options, options_table, 0, 2, kwvals); + + if (kwvals[0] == Qundef) { + salt_len = -2; // default + } else { + salt_len = NUM2INT(kwvals[0]); + } + salt_len = NUM2INT(saltlen); pkey = GetPrivPKeyPtr(self); md = GetDigestPtr(digest); @@ -910,8 +927,8 @@ Init_ossl_rsa(void) rb_define_method(cRSA, "private_encrypt", ossl_rsa_private_encrypt, -1); rb_define_method(cRSA, "private_decrypt", ossl_rsa_private_decrypt, -1); #if (OPENSSL_VERSION_NUMBER >= 0x1000100f) - rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, 4); - rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, 5); + rb_define_method(cRSA, "sign_pss", ossl_rsa_sign_pss, -1); + rb_define_method(cRSA, "verify_pss", ossl_rsa_verify_pss, -1); #endif DEF_OSSL_PKEY_BN(cRSA, rsa, n);