2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_HEADER */
|
2015-03-09 18:05:11 +01:00
|
|
|
#include "mbedtls/rsa.h"
|
2021-03-09 17:04:12 +01:00
|
|
|
#include "rsa_alt_helpers.h"
|
2024-01-23 15:19:07 +01:00
|
|
|
#include "rsa_internal.h"
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_HEADER */
|
|
|
|
|
|
|
|
/* BEGIN_DEPENDENCIES
|
2015-04-08 12:49:31 +02:00
|
|
|
* depends_on:MBEDTLS_RSA_C:MBEDTLS_BIGNUM_C:MBEDTLS_GENPRIME
|
2013-08-20 11:48:36 +02:00
|
|
|
* END_DEPENDENCIES
|
|
|
|
*/
|
|
|
|
|
2021-06-03 18:51:59 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_invalid_param()
|
2021-06-03 18:51:59 +02:00
|
|
|
{
|
|
|
|
mbedtls_rsa_context ctx;
|
|
|
|
const int invalid_padding = 42;
|
|
|
|
const int invalid_hash_id = 0xff;
|
2023-01-11 14:50:10 +01:00
|
|
|
unsigned char buf[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
|
|
|
|
size_t buf_len = sizeof(buf);
|
|
|
|
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_set_padding(&ctx,
|
|
|
|
invalid_padding,
|
|
|
|
MBEDTLS_MD_NONE),
|
|
|
|
MBEDTLS_ERR_RSA_INVALID_PADDING);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_set_padding(&ctx,
|
|
|
|
MBEDTLS_RSA_PKCS_V21,
|
|
|
|
invalid_hash_id),
|
|
|
|
MBEDTLS_ERR_RSA_INVALID_PADDING);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_pkcs1_sign(&ctx, NULL,
|
|
|
|
NULL, MBEDTLS_MD_NONE,
|
|
|
|
buf_len,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_pkcs1_sign(&ctx, NULL,
|
|
|
|
NULL, MBEDTLS_MD_SHA256,
|
|
|
|
0,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_pkcs1_verify(&ctx, MBEDTLS_MD_NONE,
|
|
|
|
buf_len,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_pkcs1_verify(&ctx, MBEDTLS_MD_SHA256,
|
|
|
|
0,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-09-01 17:18:00 +02:00
|
|
|
|
2021-06-08 10:22:28 +02:00
|
|
|
#if !defined(MBEDTLS_PKCS1_V15)
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_set_padding(&ctx,
|
|
|
|
MBEDTLS_RSA_PKCS_V15,
|
|
|
|
MBEDTLS_MD_NONE),
|
|
|
|
MBEDTLS_ERR_RSA_INVALID_PADDING);
|
2021-06-08 10:22:28 +02:00
|
|
|
#endif
|
|
|
|
|
2022-09-01 17:07:18 +02:00
|
|
|
#if defined(MBEDTLS_PKCS1_V15)
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL,
|
|
|
|
NULL, MBEDTLS_MD_NONE,
|
|
|
|
buf_len,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-07-26 11:09:24 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL,
|
|
|
|
NULL, MBEDTLS_MD_SHA256,
|
|
|
|
0,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-09-01 17:18:00 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, MBEDTLS_MD_NONE,
|
|
|
|
buf_len,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-07-26 11:09:24 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, MBEDTLS_MD_SHA256,
|
|
|
|
0,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-09-01 17:18:00 +02:00
|
|
|
|
|
|
|
|
2022-07-26 11:09:24 +02:00
|
|
|
#endif
|
|
|
|
|
2021-06-08 10:22:28 +02:00
|
|
|
#if !defined(MBEDTLS_PKCS1_V21)
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_set_padding(&ctx,
|
|
|
|
MBEDTLS_RSA_PKCS_V21,
|
|
|
|
MBEDTLS_MD_NONE),
|
|
|
|
MBEDTLS_ERR_RSA_INVALID_PADDING);
|
2021-06-08 10:22:28 +02:00
|
|
|
#endif
|
|
|
|
|
2022-07-26 11:09:24 +02:00
|
|
|
#if defined(MBEDTLS_PKCS1_V21)
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
|
|
|
|
MBEDTLS_MD_NONE, buf_len,
|
|
|
|
NULL, buf_len,
|
|
|
|
buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
|
|
|
|
MBEDTLS_MD_SHA256, 0,
|
|
|
|
NULL, buf_len,
|
|
|
|
buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_verify_ext(&ctx, MBEDTLS_MD_NONE,
|
|
|
|
buf_len, NULL,
|
|
|
|
MBEDTLS_MD_NONE,
|
|
|
|
buf_len, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_verify_ext(&ctx, MBEDTLS_MD_SHA256,
|
|
|
|
0, NULL,
|
|
|
|
MBEDTLS_MD_NONE,
|
|
|
|
buf_len, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_verify(&ctx, MBEDTLS_MD_NONE,
|
|
|
|
buf_len,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
|
|
|
|
|
|
|
TEST_EQUAL(mbedtls_rsa_rsassa_pss_verify(&ctx, MBEDTLS_MD_SHA256,
|
|
|
|
0,
|
|
|
|
NULL, buf),
|
|
|
|
MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
|
2022-07-26 11:09:24 +02:00
|
|
|
#endif
|
|
|
|
|
2021-06-03 18:51:59 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2021-06-03 18:51:59 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2021-02-01 17:55:24 +01:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_init_free(int reinit)
|
2021-02-01 17:55:24 +01:00
|
|
|
{
|
|
|
|
mbedtls_rsa_context ctx;
|
|
|
|
|
|
|
|
/* Double free is not explicitly documented to work, but we rely on it
|
|
|
|
* even inside the library so that you can call mbedtls_rsa_free()
|
|
|
|
* unconditionally on an error path without checking whether it has
|
|
|
|
* already been called in the success path. */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2021-02-01 17:55:24 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (reinit) {
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
}
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2021-02-01 17:55:24 +01:00
|
|
|
|
|
|
|
/* This test case always succeeds, functionally speaking. A plausible
|
|
|
|
* bug might trigger an invalid pointer dereference or a memory leak. */
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:35:06 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_pkcs1_sign(data_t *message_str, int padding_mode,
|
|
|
|
int digest, int mod, char *input_P,
|
|
|
|
char *input_Q, char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2009-07-07 22:18:41 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, P, Q, E;
|
2020-06-10 12:12:18 +02:00
|
|
|
mbedtls_test_rnd_pseudo_info rnd_info;
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
|
|
|
|
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
|
|
|
|
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_sign(
|
|
|
|
&ctx, &mbedtls_test_rnd_pseudo_rand, &rnd_info,
|
|
|
|
digest, message_str->len, message_str->x,
|
|
|
|
output) == result);
|
|
|
|
if (result == 0) {
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2011-05-05 13:49:20 +02:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
|
|
|
|
mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-07 22:18:41 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2022-07-16 08:35:06 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_pkcs1_verify(data_t *message_str, int padding_mode,
|
|
|
|
int digest, int mod,
|
|
|
|
char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2009-07-07 22:18:41 +02:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, digest, message_str->len, message_str->x,
|
|
|
|
result_str->x) == result);
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-07 22:18:41 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_pkcs1_sign_raw(data_t *hash_result,
|
|
|
|
int padding_mode, int mod,
|
|
|
|
char *input_P, char *input_Q,
|
|
|
|
char *input_N, char *input_E,
|
|
|
|
data_t *result_str)
|
2009-07-07 22:18:41 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, P, Q, E;
|
2020-06-10 12:12:18 +02:00
|
|
|
mbedtls_test_rnd_pseudo_info rnd_info;
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
|
|
|
|
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
2021-06-25 12:13:24 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2015-04-08 12:49:31 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_pseudo_rand,
|
|
|
|
&rnd_info, MBEDTLS_MD_NONE,
|
|
|
|
hash_result->len,
|
|
|
|
hash_result->x, output) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2011-05-05 13:49:20 +02:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
|
|
|
|
mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
|
2017-08-23 09:33:08 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-07 22:18:41 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_pkcs1_verify_raw(data_t *hash_result,
|
|
|
|
int padding_mode, int mod,
|
|
|
|
char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int correct)
|
2009-07-07 22:18:41 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
2017-08-23 09:33:08 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, MBEDTLS_MD_NONE, hash_result->len, hash_result->x,
|
|
|
|
result_str->x) == correct);
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_pkcs1_encrypt(data_t *message_str, int padding_mode,
|
|
|
|
int mod, char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2020-06-10 12:12:18 +02:00
|
|
|
mbedtls_test_rnd_pseudo_info rnd_info;
|
2011-03-13 16:45:42 +01:00
|
|
|
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
2017-08-23 09:33:08 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx,
|
|
|
|
&mbedtls_test_rnd_pseudo_rand,
|
|
|
|
&rnd_info, message_str->len,
|
|
|
|
message_str->x,
|
|
|
|
output) == result);
|
|
|
|
if (result == 0) {
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_pkcs1_encrypt_bad_rng(data_t *message_str, int padding_mode,
|
|
|
|
int mod, char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2010-07-18 21:47:14 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2010-07-18 21:47:14 +02:00
|
|
|
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
2010-07-18 21:47:14 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2010-07-18 21:47:14 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
|
2010-07-18 21:47:14 +02:00
|
|
|
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx, &mbedtls_test_rnd_zero_rand,
|
|
|
|
NULL, message_str->len,
|
|
|
|
message_str->x,
|
|
|
|
output) == result);
|
|
|
|
if (result == 0) {
|
2010-07-18 21:47:14 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2010-07-18 21:47:14 +02:00
|
|
|
}
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2010-07-18 21:47:14 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2010-07-18 21:47:14 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_pkcs1_decrypt(data_t *message_str, int padding_mode,
|
|
|
|
int mod, char *input_P,
|
|
|
|
char *input_Q, char *input_N,
|
|
|
|
char *input_E, int max_output,
|
|
|
|
data_t *result_str, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[32];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2011-04-24 17:53:29 +02:00
|
|
|
size_t output_len;
|
2020-06-10 12:12:18 +02:00
|
|
|
mbedtls_test_rnd_pseudo_info rnd_info;
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, P, Q, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
|
|
|
|
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_set_padding(&ctx, padding_mode,
|
|
|
|
MBEDTLS_MD_NONE) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2017-08-23 09:33:08 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2009-07-11 21:15:20 +02:00
|
|
|
output_len = 0;
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx, mbedtls_test_rnd_pseudo_rand,
|
|
|
|
&rnd_info,
|
|
|
|
&output_len, message_str->x, output,
|
|
|
|
max_output) == result);
|
|
|
|
if (result == 0) {
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
output_len,
|
|
|
|
result_str->len) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2011-05-05 13:49:20 +02:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
|
|
|
|
mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_public(data_t *message_str, int mod,
|
|
|
|
char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
mbedtls_rsa_init(&ctx2);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
2021-06-09 16:24:35 +02:00
|
|
|
|
|
|
|
/* Check test data consistency */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(message_str->len == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_public(&ctx, message_str->x, output) == result);
|
|
|
|
if (result == 0) {
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-02-03 11:16:44 +01:00
|
|
|
/* And now with the copy */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
|
2014-07-10 15:26:12 +02:00
|
|
|
/* clear the original to be sure */
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx2) == 0);
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_public(&ctx2, message_str->x, output) == result);
|
|
|
|
if (result == 0) {
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len, result_str->len) == 0);
|
2014-02-03 11:16:44 +01:00
|
|
|
}
|
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
|
|
|
mbedtls_rsa_free(&ctx2);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_private(data_t *message_str, int mod,
|
|
|
|
char *input_P, char *input_Q,
|
|
|
|
char *input_N, char *input_E,
|
|
|
|
data_t *result_str, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char output[256];
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, P, Q, E;
|
2020-06-10 12:12:18 +02:00
|
|
|
mbedtls_test_rnd_pseudo_info rnd_info;
|
2013-09-13 12:57:23 +02:00
|
|
|
int i;
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
|
|
|
|
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
mbedtls_rsa_init(&ctx2);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2015-04-08 12:49:31 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
|
2021-06-09 16:24:35 +02:00
|
|
|
|
|
|
|
/* Check test data consistency */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(message_str->len == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-09-13 12:57:23 +02:00
|
|
|
/* repeat three times to test updating of blinding values */
|
2023-01-11 14:50:10 +01:00
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_test_rnd_pseudo_rand,
|
|
|
|
&rnd_info, message_str->x,
|
|
|
|
output) == result);
|
|
|
|
if (result == 0) {
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx.len,
|
|
|
|
result_str->len) == 0);
|
2013-09-13 12:57:23 +02:00
|
|
|
}
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2011-05-05 13:49:20 +02:00
|
|
|
|
2014-02-03 11:16:44 +01:00
|
|
|
/* And now one more time with the copy */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
|
2014-07-10 15:26:12 +02:00
|
|
|
/* clear the original to be sure */
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx2) == 0);
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
TEST_ASSERT(mbedtls_rsa_private(&ctx2, mbedtls_test_rnd_pseudo_rand,
|
|
|
|
&rnd_info, message_str->x,
|
|
|
|
output) == result);
|
|
|
|
if (result == 0) {
|
2014-02-03 11:16:44 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
|
|
|
|
ctx2.len,
|
|
|
|
result_str->len) == 0);
|
2014-02-03 11:16:44 +01:00
|
|
|
}
|
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
|
|
|
|
mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
|
2017-08-23 09:33:08 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx); mbedtls_rsa_free(&ctx2);
|
2009-07-07 22:18:41 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-07 22:18:41 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_check_privkey_null()
|
2009-07-11 00:38:58 +02:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2023-01-11 14:50:10 +01:00
|
|
|
memset(&ctx, 0x00, sizeof(mbedtls_rsa_context));
|
2009-07-11 00:38:58 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED);
|
2009-07-11 00:38:58 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-11 00:38:58 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_check_pubkey(char *input_N, char *input_E, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2017-08-23 09:33:08 +02:00
|
|
|
mbedtls_mpi N, E;
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_rsa_init(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_N)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_E)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == result);
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
|
|
|
|
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_check_privkey(int mod, char *input_P, char *input_Q,
|
|
|
|
char *input_N, char *input_E, char *input_D,
|
|
|
|
char *input_DP, char *input_DQ, char *input_QP,
|
|
|
|
int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2013-08-20 11:48:36 +02:00
|
|
|
ctx.len = mod / 8;
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_P)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.P, input_P) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_Q)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.Q, input_Q) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_N)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.N, input_N) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_E)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.E, input_E) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_D)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.D, input_D) == 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2017-08-23 09:31:07 +02:00
|
|
|
#if !defined(MBEDTLS_RSA_NO_CRT)
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_DP)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DP, input_DP) == 0);
|
2012-09-27 22:41:37 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_DQ)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DQ, input_DQ) == 0);
|
2012-09-27 22:41:37 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_QP)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&ctx.QP, input_QP) == 0);
|
2012-09-27 22:41:37 +02:00
|
|
|
}
|
2017-08-23 09:31:07 +02:00
|
|
|
#else
|
2022-07-07 12:38:44 +02:00
|
|
|
((void) input_DP);
|
|
|
|
((void) input_DQ);
|
|
|
|
((void) input_QP);
|
2017-08-23 09:31:07 +02:00
|
|
|
#endif
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == result);
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2014-11-06 14:02:51 +01:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_check_pubpriv(int mod, char *input_Npub, char *input_Epub,
|
|
|
|
char *input_P, char *input_Q, char *input_N,
|
|
|
|
char *input_E, char *input_D, char *input_DP,
|
|
|
|
char *input_DQ, char *input_QP, int result)
|
2014-11-06 14:02:51 +01:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context pub, prv;
|
2014-11-06 14:02:51 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&pub);
|
|
|
|
mbedtls_rsa_init(&prv);
|
2014-11-06 14:02:51 +01:00
|
|
|
|
|
|
|
pub.len = mod / 8;
|
|
|
|
prv.len = mod / 8;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_Npub)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&pub.N, input_Npub) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_Epub)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&pub.E, input_Epub) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_P)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.P, input_P) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_Q)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.Q, input_Q) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_N)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.N, input_N) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_E)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.E, input_E) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_D)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.D, input_D) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2017-08-23 09:31:07 +02:00
|
|
|
#if !defined(MBEDTLS_RSA_NO_CRT)
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_DP)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.DP, input_DP) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_DQ)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.DQ, input_DQ) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
if (strlen(input_QP)) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&prv.QP, input_QP) == 0);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
2017-08-23 09:31:07 +02:00
|
|
|
#else
|
2022-07-07 12:38:44 +02:00
|
|
|
((void) input_DP);
|
|
|
|
((void) input_DQ);
|
|
|
|
((void) input_QP);
|
2017-08-23 09:31:07 +02:00
|
|
|
#endif
|
2014-11-06 14:02:51 +01:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pub_priv(&pub, &prv) == result);
|
2014-11-06 14:02:51 +01:00
|
|
|
|
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&pub);
|
|
|
|
mbedtls_rsa_free(&prv);
|
2014-11-06 14:02:51 +01:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_gen_key(int nrbits, int exponent, int result)
|
2009-07-12 15:26:42 +02:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_gen_key(&ctx, mbedtls_test_rnd_std_rand, NULL, nrbits,
|
|
|
|
exponent) == result);
|
|
|
|
if (result == 0) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx.P, &ctx.Q) > 0);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-01-03 11:33:48 +01:00
|
|
|
|
2014-07-10 15:26:12 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2009-07-12 15:26:42 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|
2009-07-12 15:26:42 +02:00
|
|
|
|
2022-07-16 08:41:34 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_deduce_primes(char *input_N,
|
|
|
|
char *input_D,
|
|
|
|
char *input_E,
|
|
|
|
char *output_P,
|
|
|
|
char *output_Q,
|
|
|
|
int corrupt, int result)
|
2017-08-23 12:00:44 +02:00
|
|
|
{
|
|
|
|
mbedtls_mpi N, P, Pp, Q, Qp, D, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N);
|
|
|
|
mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
|
|
|
|
mbedtls_mpi_init(&Pp); mbedtls_mpi_init(&Qp);
|
|
|
|
mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
|
2017-08-23 12:00:44 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Qp, output_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Pp, output_Q) == 0);
|
2017-08-23 12:00:44 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (corrupt) {
|
|
|
|
TEST_ASSERT(mbedtls_mpi_add_int(&D, &D, 2) == 0);
|
|
|
|
}
|
2017-08-23 12:00:44 +02:00
|
|
|
|
|
|
|
/* Try to deduce P, Q from N, D, E only. */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_deduce_primes(&N, &D, &E, &P, &Q) == result);
|
2017-08-23 12:00:44 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (!corrupt) {
|
2017-08-23 12:00:44 +02:00
|
|
|
/* Check if (P,Q) = (Pp, Qp) or (P,Q) = (Qp, Pp) */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT((mbedtls_mpi_cmp_mpi(&P, &Pp) == 0 && mbedtls_mpi_cmp_mpi(&Q, &Qp) == 0) ||
|
|
|
|
(mbedtls_mpi_cmp_mpi(&P, &Qp) == 0 && mbedtls_mpi_cmp_mpi(&Q, &Pp) == 0));
|
2017-08-23 12:00:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N);
|
|
|
|
mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
|
|
|
|
mbedtls_mpi_free(&Pp); mbedtls_mpi_free(&Qp);
|
|
|
|
mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
|
2017-08-23 12:00:44 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2017-08-23 12:00:21 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_deduce_private_exponent(char *input_P,
|
|
|
|
char *input_Q,
|
|
|
|
char *input_E,
|
|
|
|
char *output_D,
|
|
|
|
int corrupt, int result)
|
2017-08-23 12:00:21 +02:00
|
|
|
{
|
|
|
|
mbedtls_mpi P, Q, D, Dp, E, R, Rp;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
|
|
|
|
mbedtls_mpi_init(&D); mbedtls_mpi_init(&Dp);
|
|
|
|
mbedtls_mpi_init(&E);
|
|
|
|
mbedtls_mpi_init(&R); mbedtls_mpi_init(&Rp);
|
2017-08-23 12:00:21 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Dp, output_D) == 0);
|
2017-08-23 12:00:21 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (corrupt) {
|
2017-08-23 12:00:21 +02:00
|
|
|
/* Make E even */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_mpi_set_bit(&E, 0, 0) == 0);
|
2017-08-23 12:00:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to deduce D from N, P, Q, E. */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_deduce_private_exponent(&P, &Q,
|
|
|
|
&E, &D) == result);
|
2017-08-23 12:00:21 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (!corrupt) {
|
2017-08-23 12:00:21 +02:00
|
|
|
/*
|
|
|
|
* Check that D and Dp agree modulo LCM(P-1, Q-1).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Replace P,Q by P-1, Q-1 */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_mpi_sub_int(&P, &P, 1) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_sub_int(&Q, &Q, 1) == 0);
|
2017-08-23 12:00:21 +02:00
|
|
|
|
|
|
|
/* Check D == Dp modulo P-1 */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_mpi_mod_mpi(&R, &D, &P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_mod_mpi(&Rp, &Dp, &P) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &Rp) == 0);
|
2017-08-23 12:00:21 +02:00
|
|
|
|
|
|
|
/* Check D == Dp modulo Q-1 */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_mpi_mod_mpi(&R, &D, &Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_mod_mpi(&Rp, &Dp, &Q) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &Rp) == 0);
|
2017-08-23 12:00:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
|
|
|
|
mbedtls_mpi_free(&D); mbedtls_mpi_free(&Dp);
|
|
|
|
mbedtls_mpi_free(&E);
|
|
|
|
mbedtls_mpi_free(&R); mbedtls_mpi_free(&Rp);
|
2017-08-23 12:00:21 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_import(char *input_N,
|
|
|
|
char *input_P,
|
|
|
|
char *input_Q,
|
|
|
|
char *input_D,
|
|
|
|
char *input_E,
|
|
|
|
int successive,
|
|
|
|
int is_priv,
|
|
|
|
int res_check,
|
|
|
|
int res_complete)
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
{
|
|
|
|
mbedtls_mpi N, P, Q, D, E;
|
|
|
|
mbedtls_rsa_context ctx;
|
|
|
|
|
2017-09-29 12:51:05 +02:00
|
|
|
/* Buffers used for encryption-decryption test */
|
|
|
|
unsigned char *buf_orig = NULL;
|
|
|
|
unsigned char *buf_enc = NULL;
|
|
|
|
unsigned char *buf_dec = NULL;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
const int have_N = (strlen(input_N) > 0);
|
|
|
|
const int have_P = (strlen(input_P) > 0);
|
|
|
|
const int have_Q = (strlen(input_Q) > 0);
|
|
|
|
const int have_D = (strlen(input_D) > 0);
|
|
|
|
const int have_E = (strlen(input_E) > 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N);
|
|
|
|
mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
|
|
|
|
mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_N) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
}
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_P) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
}
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_Q) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
}
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_D) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
|
|
|
|
}
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_E) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
|
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
have_N ? &N : NULL,
|
|
|
|
have_P ? &P : NULL,
|
|
|
|
have_Q ? &Q : NULL,
|
|
|
|
have_D ? &D : NULL,
|
|
|
|
have_E ? &E : NULL) == 0);
|
|
|
|
} else {
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
/* Import N, P, Q, D, E separately.
|
|
|
|
* This should make no functional difference. */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
have_N ? &N : NULL,
|
|
|
|
NULL, NULL, NULL, NULL) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
NULL,
|
|
|
|
have_P ? &P : NULL,
|
|
|
|
NULL, NULL, NULL) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
NULL, NULL,
|
|
|
|
have_Q ? &Q : NULL,
|
|
|
|
NULL, NULL) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
NULL, NULL, NULL,
|
|
|
|
have_D ? &D : NULL,
|
|
|
|
NULL) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
NULL, NULL, NULL, NULL,
|
|
|
|
have_E ? &E : NULL) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2017-09-29 12:51:05 +02:00
|
|
|
/* On expected success, perform some public and private
|
|
|
|
* key operations to check if the key is working properly. */
|
2023-01-11 14:50:10 +01:00
|
|
|
if (res_complete == 0) {
|
|
|
|
if (is_priv) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == res_check);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == res_check);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res_check != 0) {
|
2017-10-11 11:01:33 +02:00
|
|
|
goto exit;
|
2023-01-11 14:50:10 +01:00
|
|
|
}
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
buf_orig = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
buf_enc = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
buf_dec = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
if (buf_orig == NULL || buf_enc == NULL || buf_dec == NULL) {
|
2017-09-29 12:51:05 +02:00
|
|
|
goto exit;
|
2023-01-11 14:50:10 +01:00
|
|
|
}
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_rnd_std_rand(NULL,
|
|
|
|
buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
|
|
|
/* Make sure the number we're generating is smaller than the modulus */
|
|
|
|
buf_orig[0] = 0x00;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (is_priv) {
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_test_rnd_std_rand,
|
|
|
|
NULL, buf_enc,
|
|
|
|
buf_dec) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(memcmp(buf_orig, buf_dec,
|
|
|
|
mbedtls_rsa_get_len(&ctx)) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
exit:
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_free(buf_orig);
|
|
|
|
mbedtls_free(buf_enc);
|
|
|
|
mbedtls_free(buf_dec);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N);
|
|
|
|
mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
|
|
|
|
mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2017-08-23 12:44:51 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_export(char *input_N,
|
|
|
|
char *input_P,
|
|
|
|
char *input_Q,
|
|
|
|
char *input_D,
|
|
|
|
char *input_E,
|
|
|
|
int is_priv,
|
|
|
|
int successive)
|
2017-08-23 12:44:51 +02:00
|
|
|
{
|
|
|
|
/* Original MPI's with which we set up the RSA context */
|
|
|
|
mbedtls_mpi N, P, Q, D, E;
|
|
|
|
|
|
|
|
/* Exported MPI's */
|
|
|
|
mbedtls_mpi Ne, Pe, Qe, De, Ee;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
const int have_N = (strlen(input_N) > 0);
|
|
|
|
const int have_P = (strlen(input_P) > 0);
|
|
|
|
const int have_Q = (strlen(input_Q) > 0);
|
|
|
|
const int have_D = (strlen(input_D) > 0);
|
|
|
|
const int have_E = (strlen(input_E) > 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
|
|
|
mbedtls_rsa_context ctx;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N);
|
|
|
|
mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
|
|
|
|
mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&Ne);
|
|
|
|
mbedtls_mpi_init(&Pe); mbedtls_mpi_init(&Qe);
|
|
|
|
mbedtls_mpi_init(&De); mbedtls_mpi_init(&Ee);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
|
|
|
/* Setup RSA context */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_N) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_P) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_Q) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_D) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_E) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import(&ctx,
|
|
|
|
strlen(input_N) ? &N : NULL,
|
|
|
|
strlen(input_P) ? &P : NULL,
|
|
|
|
strlen(input_Q) ? &Q : NULL,
|
|
|
|
strlen(input_D) ? &D : NULL,
|
|
|
|
strlen(input_E) ? &E : NULL) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Export parameters and compare to original ones.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* N and E must always be present. */
|
2023-01-11 14:50:10 +01:00
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, &Ne, NULL, NULL, NULL, &Ee) == 0);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, &Ne, NULL, NULL, NULL, NULL) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, NULL, NULL, &Ee) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&N, &Ne) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&E, &Ee) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
|
|
|
/* If we were providing enough information to setup a complete private context,
|
|
|
|
* we expect to be able to export all core parameters. */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (is_priv) {
|
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, &Pe, &Qe,
|
|
|
|
&De, NULL) == 0);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, &Pe, NULL,
|
|
|
|
NULL, NULL) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, &Qe,
|
|
|
|
NULL, NULL) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, NULL,
|
|
|
|
&De, NULL) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_P) {
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P, &Pe) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_Q) {
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Q, &Qe) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_D) {
|
|
|
|
TEST_ASSERT(mbedtls_mpi_cmp_mpi(&D, &De) == 0);
|
|
|
|
}
|
2017-08-23 12:44:51 +02:00
|
|
|
|
|
|
|
/* While at it, perform a sanity check */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_validate_params(&Ne, &Pe, &Qe, &De, &Ee,
|
|
|
|
NULL, NULL) == 0);
|
2017-08-23 12:44:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N);
|
|
|
|
mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
|
|
|
|
mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
|
2017-08-23 12:44:51 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&Ne);
|
|
|
|
mbedtls_mpi_free(&Pe); mbedtls_mpi_free(&Qe);
|
|
|
|
mbedtls_mpi_free(&De); mbedtls_mpi_free(&Ee);
|
2017-08-23 12:44:51 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_validate_params(char *input_N,
|
|
|
|
char *input_P,
|
|
|
|
char *input_Q,
|
|
|
|
char *input_D,
|
|
|
|
char *input_E,
|
|
|
|
int prng, int result)
|
2017-08-23 14:22:36 +02:00
|
|
|
{
|
|
|
|
/* Original MPI's with which we set up the RSA context */
|
|
|
|
mbedtls_mpi N, P, Q, D, E;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
const int have_N = (strlen(input_N) > 0);
|
|
|
|
const int have_P = (strlen(input_P) > 0);
|
|
|
|
const int have_Q = (strlen(input_Q) > 0);
|
|
|
|
const int have_D = (strlen(input_D) > 0);
|
|
|
|
const int have_E = (strlen(input_E) > 0);
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_init(&N);
|
|
|
|
mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
|
|
|
|
mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_N) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
|
|
|
|
}
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_P) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
|
|
|
|
}
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_Q) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
|
|
|
|
}
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_D) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
|
|
|
|
}
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (have_E) {
|
|
|
|
TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
|
|
|
|
}
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_validate_params(have_N ? &N : NULL,
|
|
|
|
have_P ? &P : NULL,
|
|
|
|
have_Q ? &Q : NULL,
|
|
|
|
have_D ? &D : NULL,
|
|
|
|
have_E ? &E : NULL,
|
|
|
|
prng ? mbedtls_test_rnd_std_rand : NULL,
|
|
|
|
prng ? NULL : NULL) == result);
|
2017-08-23 14:22:36 +02:00
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_mpi_free(&N);
|
|
|
|
mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
|
|
|
|
mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
|
2017-08-23 14:22:36 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:41:34 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_export_raw(data_t *input_N, data_t *input_P,
|
|
|
|
data_t *input_Q, data_t *input_D,
|
|
|
|
data_t *input_E, int is_priv,
|
|
|
|
int successive)
|
2017-08-23 12:49:22 +02:00
|
|
|
{
|
|
|
|
/* Exported buffers */
|
2018-11-22 14:47:51 +01:00
|
|
|
unsigned char bufNe[256];
|
|
|
|
unsigned char bufPe[128];
|
|
|
|
unsigned char bufQe[128];
|
|
|
|
unsigned char bufDe[256];
|
|
|
|
unsigned char bufEe[1];
|
2017-08-23 12:49:22 +02:00
|
|
|
|
|
|
|
mbedtls_rsa_context ctx;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
2017-08-23 12:49:22 +02:00
|
|
|
|
|
|
|
/* Setup RSA context */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
input_N->len ? input_N->x : NULL, input_N->len,
|
|
|
|
input_P->len ? input_P->x : NULL, input_P->len,
|
|
|
|
input_Q->len ? input_Q->x : NULL, input_Q->len,
|
|
|
|
input_D->len ? input_D->x : NULL, input_D->len,
|
|
|
|
input_E->len ? input_E->x : NULL, input_E->len) == 0);
|
2017-08-23 12:49:22 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
|
2017-08-23 12:49:22 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Export parameters and compare to original ones.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* N and E must always be present. */
|
2023-01-11 14:50:10 +01:00
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, bufNe, input_N->len,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
bufEe, input_E->len) == 0);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, bufNe, input_N->len,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
NULL, 0) == 0);
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
bufEe, input_E->len) == 0);
|
2017-08-23 12:49:22 +02:00
|
|
|
}
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(memcmp(input_N->x, bufNe, input_N->len) == 0);
|
|
|
|
TEST_ASSERT(memcmp(input_E->x, bufEe, input_E->len) == 0);
|
2017-08-23 12:49:22 +02:00
|
|
|
|
|
|
|
/* If we were providing enough information to setup a complete private context,
|
|
|
|
* we expect to be able to export all core parameters. */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (is_priv) {
|
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
|
|
|
|
bufPe, input_P->len ? input_P->len : sizeof(bufPe),
|
|
|
|
bufQe, input_Q->len ? input_Q->len : sizeof(bufQe),
|
|
|
|
bufDe, input_D->len ? input_D->len : sizeof(bufDe),
|
|
|
|
NULL, 0) == 0);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
|
|
|
|
bufPe, input_P->len ? input_P->len : sizeof(bufPe),
|
|
|
|
NULL, 0, NULL, 0,
|
|
|
|
NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0, NULL, 0,
|
|
|
|
bufQe, input_Q->len ? input_Q->len : sizeof(bufQe),
|
|
|
|
NULL, 0, NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
bufDe, input_D->len ? input_D->len : sizeof(bufDe),
|
|
|
|
NULL, 0) == 0);
|
2017-08-23 12:49:22 +02:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (input_P->len) {
|
|
|
|
TEST_ASSERT(memcmp(input_P->x, bufPe, input_P->len) == 0);
|
|
|
|
}
|
2017-08-23 12:49:22 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (input_Q->len) {
|
|
|
|
TEST_ASSERT(memcmp(input_Q->x, bufQe, input_Q->len) == 0);
|
|
|
|
}
|
2017-08-23 12:49:22 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (input_D->len) {
|
|
|
|
TEST_ASSERT(memcmp(input_D->x, bufDe, input_D->len) == 0);
|
|
|
|
}
|
2017-08-23 12:49:22 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
2017-08-23 12:49:22 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* BEGIN_CASE */
|
2023-01-11 14:50:10 +01:00
|
|
|
void mbedtls_rsa_import_raw(data_t *input_N,
|
|
|
|
data_t *input_P, data_t *input_Q,
|
|
|
|
data_t *input_D, data_t *input_E,
|
|
|
|
int successive,
|
|
|
|
int is_priv,
|
|
|
|
int res_check,
|
|
|
|
int res_complete)
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
{
|
2017-09-29 12:51:05 +02:00
|
|
|
/* Buffers used for encryption-decryption test */
|
|
|
|
unsigned char *buf_orig = NULL;
|
|
|
|
unsigned char *buf_enc = NULL;
|
|
|
|
unsigned char *buf_dec = NULL;
|
|
|
|
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
mbedtls_rsa_context ctx;
|
2017-10-02 11:08:39 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_init(&ctx);
|
|
|
|
|
|
|
|
if (!successive) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
(input_N->len > 0) ? input_N->x : NULL, input_N->len,
|
|
|
|
(input_P->len > 0) ? input_P->x : NULL, input_P->len,
|
|
|
|
(input_Q->len > 0) ? input_Q->x : NULL, input_Q->len,
|
|
|
|
(input_D->len > 0) ? input_D->x : NULL, input_D->len,
|
|
|
|
(input_E->len > 0) ? input_E->x : NULL,
|
|
|
|
input_E->len) == 0);
|
|
|
|
} else {
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
/* Import N, P, Q, D, E separately.
|
|
|
|
* This should make no functional difference. */
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
(input_N->len > 0) ? input_N->x : NULL, input_N->len,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0, NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
NULL, 0,
|
|
|
|
(input_P->len > 0) ? input_P->x : NULL, input_P->len,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
NULL, 0, NULL, 0,
|
|
|
|
(input_Q->len > 0) ? input_Q->x : NULL, input_Q->len,
|
|
|
|
NULL, 0, NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
(input_D->len > 0) ? input_D->x : NULL, input_D->len,
|
|
|
|
NULL, 0) == 0);
|
|
|
|
|
|
|
|
TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
|
|
|
|
NULL, 0, NULL, 0, NULL, 0, NULL, 0,
|
|
|
|
(input_E->len > 0) ? input_E->x : NULL,
|
|
|
|
input_E->len) == 0);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
}
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
|
2017-09-29 12:51:05 +02:00
|
|
|
/* On expected success, perform some public and private
|
|
|
|
* key operations to check if the key is working properly. */
|
2023-01-11 14:50:10 +01:00
|
|
|
if (res_complete == 0) {
|
|
|
|
if (is_priv) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == res_check);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == res_check);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res_check != 0) {
|
2017-10-11 11:01:33 +02:00
|
|
|
goto exit;
|
2023-01-11 14:50:10 +01:00
|
|
|
}
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
buf_orig = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
buf_enc = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
buf_dec = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
|
|
|
|
if (buf_orig == NULL || buf_enc == NULL || buf_dec == NULL) {
|
2017-09-29 12:51:05 +02:00
|
|
|
goto exit;
|
2023-01-11 14:50:10 +01:00
|
|
|
}
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_test_rnd_std_rand(NULL,
|
|
|
|
buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
|
|
|
/* Make sure the number we're generating is smaller than the modulus */
|
|
|
|
buf_orig[0] = 0x00;
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
if (is_priv) {
|
2022-07-16 08:57:19 +02:00
|
|
|
/* This test uses an insecure RNG, suitable only for testing.
|
|
|
|
* In production, always use a cryptographically strong RNG! */
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_test_rnd_std_rand,
|
|
|
|
NULL, buf_enc,
|
|
|
|
buf_dec) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(memcmp(buf_orig, buf_dec,
|
|
|
|
mbedtls_rsa_get_len(&ctx)) == 0);
|
2017-09-29 12:51:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
exit:
|
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_free(buf_orig);
|
|
|
|
mbedtls_free(buf_enc);
|
|
|
|
mbedtls_free(buf_dec);
|
2017-10-02 11:08:39 +02:00
|
|
|
|
2023-01-11 14:50:10 +01:00
|
|
|
mbedtls_rsa_free(&ctx);
|
Add tests for rsa_import, rsa_import_raw and rsa_complete
This commit adds numerous tests for the new library functions mbedtls_rsa_import
and mbedtls_rsa_import_raw in conjunction with mbedtls_rsa_complete for
importing and completing core sets of core RSA parameters (N,P,Q,D,E) into an
RSA context, with the importing accepting either MPI's or raw big endian
buffers.
Each test is determined by the following parameters:
1) Set of parameters provided
We're testing full sets (N,P,Q,D,E), partial sets (N,-,-,D,E) and (N,P,Q,-,E)
that are sufficient to generate missing parameters, and the partial and
insufficient set (N, -, Q, -, E).
2) Simultaenous or successive importing
The functions rsa_import and rsa_import_raw accept importing parameters at
once or one after another. We test both.
3) Sanity of parameters
2017-08-23 12:01:06 +02:00
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2024-01-24 12:33:04 +01:00
|
|
|
/* BEGIN_CASE */
|
2024-01-24 13:44:41 +01:00
|
|
|
void rsa_parse_pkcs1_key(int is_public, data_t *input, int exp_ret_val)
|
2024-01-24 12:33:04 +01:00
|
|
|
{
|
|
|
|
mbedtls_rsa_context rsa_ctx;
|
2024-01-24 13:44:41 +01:00
|
|
|
|
2024-01-24 12:33:04 +01:00
|
|
|
mbedtls_rsa_init(&rsa_ctx);
|
|
|
|
|
2024-01-24 13:44:41 +01:00
|
|
|
if (is_public) {
|
2024-02-01 17:19:37 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, input->x, input->len), exp_ret_val);
|
2024-01-24 13:44:41 +01:00
|
|
|
} else {
|
2024-02-01 17:00:29 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), exp_ret_val);
|
2024-01-24 13:44:41 +01:00
|
|
|
}
|
2024-01-24 12:33:04 +01:00
|
|
|
|
|
|
|
exit:
|
|
|
|
mbedtls_rsa_free(&rsa_ctx);
|
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2024-01-23 15:19:07 +01:00
|
|
|
/* BEGIN_CASE */
|
2024-01-24 11:24:20 +01:00
|
|
|
void rsa_parse_write_pkcs1_key(int is_public, data_t *input)
|
2024-01-23 15:19:07 +01:00
|
|
|
{
|
|
|
|
mbedtls_rsa_context rsa_ctx;
|
|
|
|
unsigned char *output_buf = NULL;
|
2024-02-01 17:53:26 +01:00
|
|
|
unsigned char *output_end, *output_p;
|
|
|
|
size_t output_len;
|
|
|
|
|
|
|
|
mbedtls_rsa_init(&rsa_ctx);
|
2024-01-23 15:19:07 +01:00
|
|
|
|
|
|
|
TEST_CALLOC(output_buf, input->len);
|
|
|
|
output_end = output_buf + input->len;
|
2024-02-01 17:53:26 +01:00
|
|
|
output_p = output_end;
|
2024-01-23 15:19:07 +01:00
|
|
|
|
2024-01-24 11:24:20 +01:00
|
|
|
/* Parse the key and write it back to output_buf. */
|
2024-01-23 15:19:07 +01:00
|
|
|
if (is_public) {
|
2024-02-01 17:19:37 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, input->x, input->len), 0);
|
2024-02-01 17:53:26 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_write_pubkey(&rsa_ctx, output_buf, &output_p), input->len);
|
2024-01-23 15:19:07 +01:00
|
|
|
} else {
|
2024-02-01 17:00:29 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), 0);
|
2024-02-01 17:53:26 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_write_key(&rsa_ctx, output_buf, &output_p), input->len);
|
2024-01-23 15:19:07 +01:00
|
|
|
}
|
2024-02-01 17:53:26 +01:00
|
|
|
output_len = output_end - output_p;
|
2024-01-24 11:24:20 +01:00
|
|
|
|
|
|
|
/* Check that the written key matches with the one provided in input. */
|
2024-02-01 17:53:26 +01:00
|
|
|
TEST_MEMORY_COMPARE(output_p, output_len, input->x, input->len);
|
2024-01-23 15:19:07 +01:00
|
|
|
|
|
|
|
exit:
|
|
|
|
mbedtls_free(output_buf);
|
|
|
|
mbedtls_rsa_free(&rsa_ctx);
|
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2024-01-30 17:35:49 +01:00
|
|
|
/* BEGIN_CASE */
|
|
|
|
void rsa_key_write_incremental(int is_public, data_t *input)
|
|
|
|
{
|
|
|
|
mbedtls_rsa_context rsa_ctx;
|
2024-02-02 11:09:37 +01:00
|
|
|
unsigned char *buf = NULL, *end, *p;
|
|
|
|
size_t i, written_data;
|
2024-01-30 17:35:49 +01:00
|
|
|
|
|
|
|
mbedtls_rsa_init(&rsa_ctx);
|
|
|
|
|
|
|
|
/* This is supposed to succeed as the real target of this test are the
|
|
|
|
* write attempt below. */
|
|
|
|
if (is_public) {
|
2024-02-01 17:19:37 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_pubkey(&rsa_ctx, input->x, input->len), 0);
|
2024-01-30 17:35:49 +01:00
|
|
|
} else {
|
2024-02-01 17:00:29 +01:00
|
|
|
TEST_EQUAL(mbedtls_rsa_parse_key(&rsa_ctx, input->x, input->len), 0);
|
2024-01-30 17:35:49 +01:00
|
|
|
}
|
|
|
|
|
2024-02-02 11:09:37 +01:00
|
|
|
/* Test with an output buffer smaller than required. */
|
2024-01-30 17:35:49 +01:00
|
|
|
for (i = 1; i < input->len; i++) {
|
|
|
|
TEST_CALLOC(buf, i);
|
|
|
|
end = buf + i;
|
2024-02-02 11:09:37 +01:00
|
|
|
p = end;
|
2024-01-30 17:35:49 +01:00
|
|
|
/* We don't care much about the return value as long as it fails. */
|
|
|
|
if (is_public) {
|
2024-02-02 11:09:37 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_write_pubkey(&rsa_ctx, buf, &p) != 0);
|
2024-01-30 17:35:49 +01:00
|
|
|
} else {
|
2024-02-02 11:09:37 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_write_key(&rsa_ctx, buf, &p) != 0);
|
2024-01-30 17:35:49 +01:00
|
|
|
}
|
|
|
|
mbedtls_free(buf);
|
|
|
|
buf = NULL;
|
|
|
|
}
|
|
|
|
|
2024-02-02 11:09:37 +01:00
|
|
|
/* Test with an output buffer equal or larger than what it is strictly required. */
|
|
|
|
for (i = input->len; i < (2 * input->len); i++) {
|
|
|
|
TEST_CALLOC(buf, i);
|
|
|
|
end = buf + i;
|
|
|
|
p = end;
|
|
|
|
/* This time all write functions must succeed. */
|
|
|
|
if (is_public) {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_write_pubkey(&rsa_ctx, buf, &p) > 0);
|
|
|
|
} else {
|
|
|
|
TEST_ASSERT(mbedtls_rsa_write_key(&rsa_ctx, buf, &p) > 0);
|
|
|
|
}
|
|
|
|
written_data = (end - p);
|
|
|
|
TEST_MEMORY_COMPARE(p, written_data, input->x, input->len);
|
|
|
|
mbedtls_free(buf);
|
|
|
|
buf = NULL;
|
2024-01-30 17:35:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
2024-02-01 17:53:26 +01:00
|
|
|
mbedtls_free(buf);
|
2024-01-30 17:35:49 +01:00
|
|
|
mbedtls_rsa_free(&rsa_ctx);
|
|
|
|
}
|
|
|
|
/* END_CASE */
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
2023-01-11 14:50:10 +01:00
|
|
|
void rsa_selftest()
|
2009-07-07 22:18:41 +02:00
|
|
|
{
|
2023-03-16 10:47:59 +01:00
|
|
|
MD_PSA_INIT();
|
2023-01-11 14:50:10 +01:00
|
|
|
TEST_ASSERT(mbedtls_rsa_self_test(1) == 0);
|
2023-03-16 10:47:59 +01:00
|
|
|
|
|
|
|
exit:
|
|
|
|
MD_PSA_DONE();
|
2009-07-07 22:18:41 +02:00
|
|
|
}
|
2013-08-20 11:48:36 +02:00
|
|
|
/* END_CASE */
|