/* BEGIN_HEADER */
#include "mbedtls/rsa.h"
#include "mbedtls/rsa_internal.h"
#include "mbedtls/md2.h"
#include "mbedtls/md4.h"
#include "mbedtls/md5.h"
#include "mbedtls/sha1.h"
#include "mbedtls/sha256.h"
#include "mbedtls/sha512.h"
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"

/* END_HEADER */

/* BEGIN_DEPENDENCIES
 * depends_on:MBEDTLS_RSA_C:MBEDTLS_BIGNUM_C:MBEDTLS_GENPRIME
 * END_DEPENDENCIES
 */

/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
void rsa_invalid_param()
{
    mbedtls_rsa_context ctx;
    const int valid_padding = MBEDTLS_RSA_PKCS_V21;
    const int invalid_padding = 42;
    const int valid_mode = MBEDTLS_RSA_PRIVATE;
    const int invalid_mode = 42;
    unsigned char buf[42] = { 0 };
    size_t olen;

    TEST_INVALID_PARAM(mbedtls_rsa_init(NULL, valid_padding, 0));
    TEST_INVALID_PARAM(mbedtls_rsa_init(&ctx, invalid_padding, 0));
    TEST_VALID_PARAM(mbedtls_rsa_free(NULL));

    /* No more variants because only the first argument must be non-NULL. */
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_import(NULL, NULL, NULL,
                                              NULL, NULL, NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_import_raw(NULL,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_complete(NULL));

    /* No more variants because only the first argument must be non-NULL. */
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_export(NULL, NULL, NULL,
                                              NULL, NULL, NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_export_raw(NULL,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0,
                                                  NULL, 0));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_export_crt(NULL, NULL, NULL, NULL));

    TEST_INVALID_PARAM(mbedtls_rsa_set_padding(NULL,
                                               valid_padding, 0));
    TEST_INVALID_PARAM(mbedtls_rsa_set_padding(&ctx,
                                               invalid_padding, 0));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_gen_key(NULL,
                                               mbedtls_test_rnd_std_rand,
                                               NULL, 0, 0));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_gen_key(&ctx, NULL,
                                               NULL, 0, 0));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_check_pubkey(NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_check_privkey(NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_check_pub_priv(NULL, &ctx));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_check_pub_priv(&ctx, NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_public(NULL, buf, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_public(&ctx, NULL, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_public(&ctx, buf, NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_private(NULL, NULL, NULL,
                                               buf, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_private(&ctx, NULL, NULL,
                                               NULL, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_private(&ctx, NULL, NULL,
                                               buf, NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_encrypt(NULL, NULL, NULL,
                                                     valid_mode,
                                                     sizeof(buf), buf,
                                                     buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
                                                     invalid_mode,
                                                     sizeof(buf), buf,
                                                     buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
                                                     valid_mode,
                                                     sizeof(buf), NULL,
                                                     buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
                                                     valid_mode,
                                                     sizeof(buf), buf,
                                                     NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_encrypt(NULL, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               sizeof(buf), buf,
                                                               buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
                                                               NULL,
                                                               invalid_mode,
                                                               sizeof(buf), buf,
                                                               buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               sizeof(buf), NULL,
                                                               buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               sizeof(buf), buf,
                                                               NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_encrypt(NULL, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          sizeof(buf), buf,
                                                          buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
                                                          invalid_mode,
                                                          buf, sizeof(buf),
                                                          sizeof(buf), buf,
                                                          buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          NULL, sizeof(buf),
                                                          sizeof(buf), buf,
                                                          buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          sizeof(buf), NULL,
                                                          buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          sizeof(buf), buf,
                                                          NULL));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_decrypt(NULL, NULL, NULL,
                                                     valid_mode, &olen,
                                                     buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
                                                     invalid_mode, &olen,
                                                     buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
                                                     valid_mode, NULL,
                                                     buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
                                                     valid_mode, &olen,
                                                     NULL, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
                                                     valid_mode, &olen,
                                                     buf, NULL, 42));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_decrypt(NULL, NULL,
                                                               NULL,
                                                               valid_mode, &olen,
                                                               buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
                                                               NULL,
                                                               invalid_mode, &olen,
                                                               buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
                                                               NULL,
                                                               valid_mode, NULL,
                                                               buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
                                                               NULL,
                                                               valid_mode, &olen,
                                                               NULL, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
                                                               NULL,
                                                               valid_mode, &olen,
                                                               buf, NULL, 42));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_decrypt(NULL, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          &olen,
                                                          buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
                                                          invalid_mode,
                                                          buf, sizeof(buf),
                                                          &olen,
                                                          buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          NULL, sizeof(buf),
                                                          NULL,
                                                          buf, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          &olen,
                                                          NULL, buf, 42));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
                                                          valid_mode,
                                                          buf, sizeof(buf),
                                                          &olen,
                                                          buf, NULL, 42));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_sign(NULL, NULL, NULL,
                                                  valid_mode,
                                                  0, sizeof(buf), buf,
                                                  buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
                                                  invalid_mode,
                                                  0, sizeof(buf), buf,
                                                  buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
                                                  valid_mode,
                                                  0, sizeof(buf), NULL,
                                                  buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
                                                  valid_mode,
                                                  0, sizeof(buf), buf,
                                                  NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
                                                  valid_mode,
                                                  MBEDTLS_MD_SHA1,
                                                  0, NULL,
                                                  buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_sign(NULL, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf), buf,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
                                                             invalid_mode,
                                                             0, sizeof(buf), buf,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf), NULL,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf), buf,
                                                             NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             MBEDTLS_MD_SHA1,
                                                             0, NULL,
                                                             buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign(NULL, NULL, NULL,
                                                       valid_mode,
                                                       0, sizeof(buf), buf,
                                                       buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
                                                       invalid_mode,
                                                       0, sizeof(buf), buf,
                                                       buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
                                                       valid_mode,
                                                       0, sizeof(buf), NULL,
                                                       buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
                                                       valid_mode,
                                                       0, sizeof(buf), buf,
                                                       NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
                                                       valid_mode,
                                                       MBEDTLS_MD_SHA1,
                                                       0, NULL,
                                                       buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign_ext(NULL, NULL, NULL,
                                                           0, sizeof(buf), buf,
                                                           MBEDTLS_RSA_SALT_LEN_ANY,
                                                           buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
                                                           0, sizeof(buf), NULL,
                                                           MBEDTLS_RSA_SALT_LEN_ANY,
                                                           buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
                                                           0, sizeof(buf), buf,
                                                           MBEDTLS_RSA_SALT_LEN_ANY,
                                                           NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
                                                           MBEDTLS_MD_SHA1,
                                                           0, NULL,
                                                           MBEDTLS_RSA_SALT_LEN_ANY,
                                                           buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_verify(NULL, NULL, NULL,
                                                    valid_mode,
                                                    0, sizeof(buf), buf,
                                                    buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
                                                    invalid_mode,
                                                    0, sizeof(buf), buf,
                                                    buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
                                                    valid_mode,
                                                    0, sizeof(buf), NULL,
                                                    buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
                                                    valid_mode,
                                                    0, sizeof(buf), buf,
                                                    NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
                                                    valid_mode,
                                                    MBEDTLS_MD_SHA1, 0, NULL,
                                                    buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_verify(NULL, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               0, sizeof(buf), buf,
                                                               buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
                                                               NULL,
                                                               invalid_mode,
                                                               0, sizeof(buf), buf,
                                                               buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               0, sizeof(buf),
                                                               NULL, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               0, sizeof(buf), buf,
                                                               NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
                                                               NULL,
                                                               valid_mode,
                                                               MBEDTLS_MD_SHA1,
                                                               0, NULL,
                                                               buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify(NULL, NULL, NULL,
                                                         valid_mode,
                                                         0, sizeof(buf),
                                                         buf, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
                                                         invalid_mode,
                                                         0, sizeof(buf),
                                                         buf, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
                                                         valid_mode,
                                                         0, sizeof(buf),
                                                         NULL, buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
                                                         valid_mode,
                                                         0, sizeof(buf),
                                                         buf, NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
                                                         valid_mode,
                                                         MBEDTLS_MD_SHA1,
                                                         0, NULL,
                                                         buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify_ext(NULL, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf),
                                                             buf,
                                                             0, 0,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
                                                             invalid_mode,
                                                             0, sizeof(buf),
                                                             buf,
                                                             0, 0,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf),
                                                             NULL, 0, 0,
                                                             buf));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             0, sizeof(buf),
                                                             buf, 0, 0,
                                                             NULL));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
                                                             valid_mode,
                                                             MBEDTLS_MD_SHA1,
                                                             0, NULL,
                                                             0, 0,
                                                             buf));

    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_copy(NULL, &ctx));
    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
                           mbedtls_rsa_copy(&ctx, NULL));

exit:
    return;
}
/* END_CASE */

/* BEGIN_CASE */
void rsa_init_free(int reinit)
{
    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. */

    mbedtls_rsa_init(&ctx, 0, 0);
    mbedtls_rsa_free(&ctx);

    if (reinit) {
        mbedtls_rsa_init(&ctx, 0, 0);
    }
    mbedtls_rsa_free(&ctx);

    /* This test case always succeeds, functionally speaking. A plausible
     * bug might trigger an invalid pointer dereference or a memory leak. */
    goto exit;
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
    unsigned char output[256];
    mbedtls_rsa_context ctx;
    mbedtls_mpi N, P, Q, E;
    mbedtls_test_rnd_pseudo_info rnd_info;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
    mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, padding_mode, 0);

    memset(hash_result, 0x00, sizeof(hash_result));
    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);


    if (mbedtls_md_info_from_type(digest) != NULL) {
        TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
                               hash_result) == 0);
    }

    TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_pseudo_rand,
                                       &rnd_info, MBEDTLS_RSA_PRIVATE, digest,
                                       0, hash_result, output) == result);
    if (result == 0) {

        TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                        ctx.len, result_str->len) == 0);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
    mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
    mbedtls_rsa_context ctx;

    mbedtls_mpi N, E;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, padding_mode, 0);
    memset(hash_result, 0x00, sizeof(hash_result));

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


    if (mbedtls_md_info_from_type(digest) != NULL) {
        TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
                               hash_result) == 0);
    }

    TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0,
                                         hash_result, result_str->x) == result);

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */


/* BEGIN_CASE */
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)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx;
    mbedtls_mpi N, P, Q, E;
    mbedtls_test_rnd_pseudo_info rnd_info;

    mbedtls_rsa_init(&ctx, padding_mode, 0);
    mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
    mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);

    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, MBEDTLS_RSA_PRIVATE,
                                       MBEDTLS_MD_NONE, hash_result->len,
                                       hash_result->x, output) == 0);


    TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                    ctx.len, result_str->len) == 0);

#if defined(MBEDTLS_PKCS1_V15)
    /* For PKCS#1 v1.5, there is an alternative way to generate signatures */
    if (padding_mode == MBEDTLS_RSA_PKCS_V15) {
        int res;
        memset(output, 0x00, sizeof(output));

        res = mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx,
                                                  &mbedtls_test_rnd_pseudo_rand, &rnd_info,
                                                  MBEDTLS_RSA_PRIVATE, hash_result->len,
                                                  hash_result->x, output);

#if !defined(MBEDTLS_RSA_ALT)
        TEST_ASSERT(res == 0);
#else
        TEST_ASSERT((res == 0) ||
                    (res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION));
#endif

        if (res == 0) {
            TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                            ctx.len,
                                            result_str->len) == 0);
        }
    }
#endif /* MBEDTLS_PKCS1_V15 */

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
    mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);

    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx;

    mbedtls_mpi N, E;
    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);

    mbedtls_rsa_init(&ctx, padding_mode, 0);
    memset(output, 0x00, sizeof(output));

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


    TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_NONE,
                                         hash_result->len, hash_result->x,
                                         result_str->x) == correct);

#if defined(MBEDTLS_PKCS1_V15)
    /* For PKCS#1 v1.5, there is an alternative way to verify signatures */
    if (padding_mode == MBEDTLS_RSA_PKCS_V15) {
        int res;
        int ok;
        size_t olen;

        res = mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx,
                                                  NULL, NULL, MBEDTLS_RSA_PUBLIC,
                                                  &olen, result_str->x, output, sizeof(output));

#if !defined(MBEDTLS_RSA_ALT)
        TEST_ASSERT(res == 0);
#else
        TEST_ASSERT((res == 0) ||
                    (res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION));
#endif

        if (res == 0) {
            ok = olen == hash_result->len && memcmp(output, hash_result->x, olen) == 0;
            if (correct == 0) {
                TEST_ASSERT(ok == 1);
            } else {
                TEST_ASSERT(ok == 0);
            }
        }
    }
#endif /* MBEDTLS_PKCS1_V15 */

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx;
    mbedtls_test_rnd_pseudo_info rnd_info;

    mbedtls_mpi N, E;
    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);

    memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));

    mbedtls_rsa_init(&ctx, padding_mode, 0);
    memset(output, 0x00, sizeof(output));

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


    TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx,
                                          &mbedtls_test_rnd_pseudo_rand,
                                          &rnd_info, MBEDTLS_RSA_PUBLIC,
                                          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);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx;

    mbedtls_mpi N, E;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, padding_mode, 0);
    memset(output, 0x00, sizeof(output));

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


    TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx, &mbedtls_test_rnd_zero_rand,
                                          NULL, MBEDTLS_RSA_PUBLIC,
                                          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);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char output[32];
    mbedtls_rsa_context ctx;
    size_t output_len;
    mbedtls_test_rnd_pseudo_info rnd_info;
    mbedtls_mpi N, P, Q, E;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
    mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);

    mbedtls_rsa_init(&ctx, padding_mode, 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);

    output_len = 0;

    TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx, mbedtls_test_rnd_pseudo_rand,
                                          &rnd_info, MBEDTLS_RSA_PRIVATE,
                                          &output_len, message_str->x, output,
                                          max_output) == result);
    if (result == 0) {

        TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                        output_len,
                                        result_str->len) == 0);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
    mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
void mbedtls_rsa_public(data_t *message_str, int mod,
                        char *input_N, char *input_E,
                        data_t *result_str, int result)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */

    mbedtls_mpi N, E;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
    mbedtls_rsa_init(&ctx2, MBEDTLS_RSA_PKCS_V15, 0);
    memset(output, 0x00, sizeof(output));

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

    /* Check test data consistency */
    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);

    TEST_ASSERT(mbedtls_rsa_public(&ctx, message_str->x, output) == result);
    if (result == 0) {

        TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                        ctx.len, result_str->len) == 0);
    }

    /* And now with the copy */
    TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
    /* clear the original to be sure */
    mbedtls_rsa_free(&ctx);

    TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx2) == 0);

    memset(output, 0x00, sizeof(output));
    TEST_ASSERT(mbedtls_rsa_public(&ctx2, message_str->x, output) == result);
    if (result == 0) {

        TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                        ctx.len, result_str->len) == 0);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
    mbedtls_rsa_free(&ctx2);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    unsigned char output[256];
    mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
    mbedtls_mpi N, P, Q, E;
    mbedtls_test_rnd_pseudo_info rnd_info;
    int i;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
    mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
    mbedtls_rsa_init(&ctx2, MBEDTLS_RSA_PKCS_V15, 0);

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

    /* Check test data consistency */
    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);

    /* repeat three times to test updating of blinding values */
    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);
        }
    }

    /* And now one more time with the copy */
    TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
    /* clear the original to be sure */
    mbedtls_rsa_free(&ctx);

    TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx2) == 0);

    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) {

        TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
                                        ctx2.len,
                                        result_str->len) == 0);
    }

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
    mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);

    mbedtls_rsa_free(&ctx); mbedtls_rsa_free(&ctx2);
}
/* END_CASE */

/* BEGIN_CASE */
void rsa_check_privkey_null()
{
    mbedtls_rsa_context ctx;
    memset(&ctx, 0x00, sizeof(mbedtls_rsa_context));

    TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED);
}
/* END_CASE */

/* BEGIN_CASE */
void mbedtls_rsa_check_pubkey(char *input_N, char *input_E, int result)
{
    mbedtls_rsa_context ctx;
    mbedtls_mpi N, E;

    mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
    mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);

    if (strlen(input_N)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
    }
    if (strlen(input_E)) {
        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_check_pubkey(&ctx) == result);

exit:
    mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    mbedtls_rsa_context ctx;

    mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);

    ctx.len = mod / 8;
    if (strlen(input_P)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.P, input_P) == 0);
    }
    if (strlen(input_Q)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.Q, input_Q) == 0);
    }
    if (strlen(input_N)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.N, input_N) == 0);
    }
    if (strlen(input_E)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.E, input_E) == 0);
    }
    if (strlen(input_D)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.D, input_D) == 0);
    }
#if !defined(MBEDTLS_RSA_NO_CRT)
    if (strlen(input_DP)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DP, input_DP) == 0);
    }
    if (strlen(input_DQ)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DQ, input_DQ) == 0);
    }
    if (strlen(input_QP)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&ctx.QP, input_QP) == 0);
    }
#else
    ((void) input_DP);
    ((void) input_DQ);
    ((void) input_QP);
#endif

    TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == result);

exit:
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE */
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)
{
    mbedtls_rsa_context pub, prv;

    mbedtls_rsa_init(&pub, MBEDTLS_RSA_PKCS_V15, 0);
    mbedtls_rsa_init(&prv, MBEDTLS_RSA_PKCS_V15, 0);

    pub.len = mod / 8;
    prv.len = mod / 8;

    if (strlen(input_Npub)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&pub.N, input_Npub) == 0);
    }
    if (strlen(input_Epub)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&pub.E, input_Epub) == 0);
    }

    if (strlen(input_P)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.P, input_P) == 0);
    }
    if (strlen(input_Q)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.Q, input_Q) == 0);
    }
    if (strlen(input_N)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.N, input_N) == 0);
    }
    if (strlen(input_E)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.E, input_E) == 0);
    }
    if (strlen(input_D)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.D, input_D) == 0);
    }
#if !defined(MBEDTLS_RSA_NO_CRT)
    if (strlen(input_DP)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.DP, input_DP) == 0);
    }
    if (strlen(input_DQ)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.DQ, input_DQ) == 0);
    }
    if (strlen(input_QP)) {
        TEST_ASSERT(mbedtls_test_read_mpi(&prv.QP, input_QP) == 0);
    }
#else
    ((void) input_DP);
    ((void) input_DQ);
    ((void) input_QP);
#endif

    TEST_ASSERT(mbedtls_rsa_check_pub_priv(&pub, &prv) == result);

exit:
    mbedtls_rsa_free(&pub);
    mbedtls_rsa_free(&prv);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
void mbedtls_rsa_gen_key(int nrbits, int exponent, int result)
{
    mbedtls_rsa_context ctx;
    mbedtls_entropy_context entropy;
    mbedtls_ctr_drbg_context ctr_drbg;
    const char *pers = "test_suite_rsa";

    mbedtls_ctr_drbg_init(&ctr_drbg);
    mbedtls_entropy_init(&entropy);
    mbedtls_rsa_init(&ctx, 0, 0);

    TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
                                      &entropy, (const unsigned char *) pers,
                                      strlen(pers)) == 0);

    TEST_ASSERT(mbedtls_rsa_gen_key(&ctx, mbedtls_ctr_drbg_random, &ctr_drbg, 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);
    }

exit:
    mbedtls_rsa_free(&ctx);
    mbedtls_ctr_drbg_free(&ctr_drbg);
    mbedtls_entropy_free(&entropy);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C */
void mbedtls_rsa_deduce_primes(char *input_N,
                               char *input_D,
                               char *input_E,
                               char *output_P,
                               char *output_Q,
                               int corrupt, int result)
{
    mbedtls_mpi N, P, Pp, Q, Qp, D, E;

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

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

    if (corrupt) {
        TEST_ASSERT(mbedtls_mpi_add_int(&D, &D, 2) == 0);
    }

    /* Try to deduce P, Q from N, D, E only. */
    TEST_ASSERT(mbedtls_rsa_deduce_primes(&N, &D, &E, &P, &Q) == result);

    if (!corrupt) {
        /* Check if (P,Q) = (Pp, Qp) or (P,Q) = (Qp, Pp) */
        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));
    }

exit:
    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);
}
/* END_CASE */

/* BEGIN_CASE */
void mbedtls_rsa_deduce_private_exponent(char *input_P,
                                         char *input_Q,
                                         char *input_E,
                                         char *output_D,
                                         int corrupt, int result)
{
    mbedtls_mpi P, Q, D, Dp, E, R, Rp;

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

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

    if (corrupt) {
        /* Make E even */
        TEST_ASSERT(mbedtls_mpi_set_bit(&E, 0, 0) == 0);
    }

    /* Try to deduce D from N, P, Q, E. */
    TEST_ASSERT(mbedtls_rsa_deduce_private_exponent(&P, &Q,
                                                    &E, &D) == result);

    if (!corrupt) {
        /*
         * Check that D and Dp agree modulo LCM(P-1, Q-1).
         */

        /* Replace P,Q by P-1, Q-1 */
        TEST_ASSERT(mbedtls_mpi_sub_int(&P, &P, 1) == 0);
        TEST_ASSERT(mbedtls_mpi_sub_int(&Q, &Q, 1) == 0);

        /* Check D == Dp modulo P-1 */
        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);

        /* Check D == Dp modulo Q-1 */
        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);
    }

exit:

    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);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
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)
{
    mbedtls_mpi N, P, Q, D, E;
    mbedtls_rsa_context ctx;

    /* Buffers used for encryption-decryption test */
    unsigned char *buf_orig = NULL;
    unsigned char *buf_enc  = NULL;
    unsigned char *buf_dec  = NULL;

    mbedtls_entropy_context entropy;
    mbedtls_ctr_drbg_context ctr_drbg;
    const char *pers = "test_suite_rsa";

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

    mbedtls_ctr_drbg_init(&ctr_drbg);
    mbedtls_entropy_init(&entropy);
    mbedtls_rsa_init(&ctx, 0, 0);

    mbedtls_mpi_init(&N);
    mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
    mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);

    TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
                                      (const unsigned char *) pers, strlen(pers)) == 0);

    if (have_N) {
        TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
    }

    if (have_P) {
        TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
    }

    if (have_Q) {
        TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
    }

    if (have_D) {
        TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
    }

    if (have_E) {
        TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
    }

    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 {
        /* Import N, P, Q, D, E separately.
         * This should make no functional difference. */

        TEST_ASSERT(mbedtls_rsa_import(&ctx,
                                       have_N ? &N : NULL,
                                       NULL, NULL, NULL, NULL) == 0);

        TEST_ASSERT(mbedtls_rsa_import(&ctx,
                                       NULL,
                                       have_P ? &P : NULL,
                                       NULL, NULL, NULL) == 0);

        TEST_ASSERT(mbedtls_rsa_import(&ctx,
                                       NULL, NULL,
                                       have_Q ? &Q : NULL,
                                       NULL, NULL) == 0);

        TEST_ASSERT(mbedtls_rsa_import(&ctx,
                                       NULL, NULL, NULL,
                                       have_D ? &D : NULL,
                                       NULL) == 0);

        TEST_ASSERT(mbedtls_rsa_import(&ctx,
                                       NULL, NULL, NULL, NULL,
                                       have_E ? &E : NULL) == 0);
    }

    TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);

    /* On expected success, perform some public and private
     * key operations to check if the key is working properly. */
    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) {
            goto exit;
        }

        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) {
            goto exit;
        }

        TEST_ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg,
                                            buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);

        /* Make sure the number we're generating is smaller than the modulus */
        buf_orig[0] = 0x00;

        TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);

        if (is_priv) {
            TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_ctr_drbg_random,
                                            &ctr_drbg, buf_enc,
                                            buf_dec) == 0);

            TEST_ASSERT(memcmp(buf_orig, buf_dec,
                               mbedtls_rsa_get_len(&ctx)) == 0);
        }
    }

exit:

    mbedtls_free(buf_orig);
    mbedtls_free(buf_enc);
    mbedtls_free(buf_dec);

    mbedtls_rsa_free(&ctx);

    mbedtls_ctr_drbg_free(&ctr_drbg);
    mbedtls_entropy_free(&entropy);

    mbedtls_mpi_free(&N);
    mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
    mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
}
/* END_CASE */

/* BEGIN_CASE */
void mbedtls_rsa_export(char *input_N,
                        char *input_P,
                        char *input_Q,
                        char *input_D,
                        char *input_E,
                        int is_priv,
                        int successive)
{
    /* 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;

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

    mbedtls_rsa_context ctx;

    mbedtls_rsa_init(&ctx, 0, 0);

    mbedtls_mpi_init(&N);
    mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
    mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);

    mbedtls_mpi_init(&Ne);
    mbedtls_mpi_init(&Pe); mbedtls_mpi_init(&Qe);
    mbedtls_mpi_init(&De); mbedtls_mpi_init(&Ee);

    /* Setup RSA context */

    if (have_N) {
        TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
    }

    if (have_P) {
        TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
    }

    if (have_Q) {
        TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
    }

    if (have_D) {
        TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
    }

    if (have_E) {
        TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
    }

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

    TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);

    /*
     * Export parameters and compare to original ones.
     */

    /* N and E must always be present. */
    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);
    }
    TEST_ASSERT(mbedtls_mpi_cmp_mpi(&N, &Ne) == 0);
    TEST_ASSERT(mbedtls_mpi_cmp_mpi(&E, &Ee) == 0);

    /* If we were providing enough information to setup a complete private context,
     * we expect to be able to export all core parameters. */

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

        if (have_P) {
            TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P, &Pe) == 0);
        }

        if (have_Q) {
            TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Q, &Qe) == 0);
        }

        if (have_D) {
            TEST_ASSERT(mbedtls_mpi_cmp_mpi(&D, &De) == 0);
        }

        /* While at it, perform a sanity check */
        TEST_ASSERT(mbedtls_rsa_validate_params(&Ne, &Pe, &Qe, &De, &Ee,
                                                NULL, NULL) == 0);
    }

exit:

    mbedtls_rsa_free(&ctx);

    mbedtls_mpi_free(&N);
    mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
    mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);

    mbedtls_mpi_free(&Ne);
    mbedtls_mpi_free(&Pe); mbedtls_mpi_free(&Qe);
    mbedtls_mpi_free(&De); mbedtls_mpi_free(&Ee);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
void mbedtls_rsa_validate_params(char *input_N,
                                 char *input_P,
                                 char *input_Q,
                                 char *input_D,
                                 char *input_E,
                                 int prng, int result)
{
    /* Original MPI's with which we set up the RSA context */
    mbedtls_mpi N, P, Q, D, E;

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

    mbedtls_entropy_context entropy;
    mbedtls_ctr_drbg_context ctr_drbg;
    const char *pers = "test_suite_rsa";

    mbedtls_mpi_init(&N);
    mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
    mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);

    mbedtls_ctr_drbg_init(&ctr_drbg);
    mbedtls_entropy_init(&entropy);
    TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
                                      &entropy, (const unsigned char *) pers,
                                      strlen(pers)) == 0);

    if (have_N) {
        TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
    }

    if (have_P) {
        TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
    }

    if (have_Q) {
        TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
    }

    if (have_D) {
        TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
    }

    if (have_E) {
        TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
    }

    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_ctr_drbg_random : NULL,
                                            prng ? &ctr_drbg : NULL) == result);
exit:

    mbedtls_ctr_drbg_free(&ctr_drbg);
    mbedtls_entropy_free(&entropy);

    mbedtls_mpi_free(&N);
    mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
    mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C */
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)
{
    /* Exported buffers */
    unsigned char bufNe[256];
    unsigned char bufPe[128];
    unsigned char bufQe[128];
    unsigned char bufDe[256];
    unsigned char bufEe[1];

    mbedtls_rsa_context ctx;

    mbedtls_rsa_init(&ctx, 0, 0);

    /* Setup RSA context */
    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);

    TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);

    /*
     * Export parameters and compare to original ones.
     */

    /* N and E must always be present. */
    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);
    }
    TEST_ASSERT(memcmp(input_N->x, bufNe, input_N->len) == 0);
    TEST_ASSERT(memcmp(input_E->x, bufEe, input_E->len) == 0);

    /* If we were providing enough information to setup a complete private context,
     * we expect to be able to export all core parameters. */

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

        if (input_P->len) {
            TEST_ASSERT(memcmp(input_P->x, bufPe, input_P->len) == 0);
        }

        if (input_Q->len) {
            TEST_ASSERT(memcmp(input_Q->x, bufQe, input_Q->len) == 0);
        }

        if (input_D->len) {
            TEST_ASSERT(memcmp(input_D->x, bufDe, input_D->len) == 0);
        }

    }

exit:
    mbedtls_rsa_free(&ctx);
}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
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)
{
    /* Buffers used for encryption-decryption test */
    unsigned char *buf_orig = NULL;
    unsigned char *buf_enc  = NULL;
    unsigned char *buf_dec  = NULL;

    mbedtls_rsa_context ctx;
    mbedtls_entropy_context entropy;
    mbedtls_ctr_drbg_context ctr_drbg;

    const char *pers = "test_suite_rsa";

    mbedtls_ctr_drbg_init(&ctr_drbg);
    mbedtls_entropy_init(&entropy);
    mbedtls_rsa_init(&ctx, 0, 0);

    TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
                                      &entropy, (const unsigned char *) pers,
                                      strlen(pers)) == 0);

    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 {
        /* Import N, P, Q, D, E separately.
         * This should make no functional difference. */

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

    TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);

    /* On expected success, perform some public and private
     * key operations to check if the key is working properly. */
    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) {
            goto exit;
        }

        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) {
            goto exit;
        }

        TEST_ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg,
                                            buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);

        /* Make sure the number we're generating is smaller than the modulus */
        buf_orig[0] = 0x00;

        TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);

        if (is_priv) {
            TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_ctr_drbg_random,
                                            &ctr_drbg, buf_enc,
                                            buf_dec) == 0);

            TEST_ASSERT(memcmp(buf_orig, buf_dec,
                               mbedtls_rsa_get_len(&ctx)) == 0);
        }
    }

exit:

    mbedtls_free(buf_orig);
    mbedtls_free(buf_enc);
    mbedtls_free(buf_dec);

    mbedtls_rsa_free(&ctx);

    mbedtls_ctr_drbg_free(&ctr_drbg);
    mbedtls_entropy_free(&entropy);

}
/* END_CASE */

/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void rsa_selftest()
{
    TEST_ASSERT(mbedtls_rsa_self_test(1) == 0);
}
/* END_CASE */
