quickjs-tart

quickjs-based runtime for wallet-core logic
Log | Files | Refs | README | LICENSE

test_suite_pkcs12.function (5298B)


      1 /* BEGIN_HEADER */
      2 #include "mbedtls/pkcs12.h"
      3 #include "common.h"
      4 
      5 typedef enum {
      6     USE_NULL_INPUT = 0,
      7     USE_GIVEN_INPUT = 1,
      8 } input_usage_method_t;
      9 
     10 /* END_HEADER */
     11 
     12 /* BEGIN_DEPENDENCIES
     13  * depends_on:MBEDTLS_PKCS12_C
     14  * END_DEPENDENCIES
     15  */
     16 
     17 /* BEGIN_CASE */
     18 void pkcs12_derive_key(int md_type, int key_size_arg,
     19                        data_t *password_arg, int password_usage,
     20                        data_t *salt_arg, int salt_usage,
     21                        int iterations,
     22                        data_t *expected_output, int expected_status)
     23 
     24 {
     25     unsigned char *output_data = NULL;
     26 
     27     unsigned char *password = NULL;
     28     size_t password_len = 0;
     29     unsigned char *salt = NULL;
     30     size_t salt_len = 0;
     31     size_t key_size = key_size_arg;
     32 
     33     MD_PSA_INIT();
     34 
     35     if (password_usage == USE_GIVEN_INPUT) {
     36         password = password_arg->x;
     37     }
     38 
     39     password_len = password_arg->len;
     40 
     41     if (salt_usage == USE_GIVEN_INPUT) {
     42         salt = salt_arg->x;
     43     }
     44 
     45     salt_len = salt_arg->len;
     46 
     47     TEST_CALLOC(output_data, key_size);
     48 
     49     int ret = mbedtls_pkcs12_derivation(output_data,
     50                                         key_size,
     51                                         password,
     52                                         password_len,
     53                                         salt,
     54                                         salt_len,
     55                                         md_type,
     56                                         MBEDTLS_PKCS12_DERIVE_KEY,
     57                                         iterations);
     58 
     59     TEST_EQUAL(ret, expected_status);
     60 
     61     if (expected_status == 0) {
     62         TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
     63                             output_data, key_size);
     64     }
     65 
     66 exit:
     67     mbedtls_free(output_data);
     68     MD_PSA_DONE();
     69 }
     70 /* END_CASE */
     71 
     72 /* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C:MBEDTLS_CIPHER_C */
     73 void pkcs12_pbe_encrypt(int params_tag, int cipher, int md, data_t *params_hex, data_t *pw,
     74                         data_t *data, int outsize, int ref_ret, data_t *ref_out)
     75 {
     76     int my_ret;
     77     mbedtls_asn1_buf pbe_params;
     78     unsigned char *my_out = NULL;
     79     mbedtls_cipher_type_t cipher_alg = (mbedtls_cipher_type_t) cipher;
     80     mbedtls_md_type_t md_alg = (mbedtls_md_type_t) md;
     81 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
     82     size_t my_out_len = 0;
     83 #endif
     84 
     85     MD_PSA_INIT();
     86 
     87     TEST_CALLOC(my_out, outsize);
     88 
     89     pbe_params.tag = params_tag;
     90     pbe_params.len = params_hex->len;
     91     pbe_params.p = params_hex->x;
     92 
     93 #if defined(MBEDTLS_TEST_DEPRECATED)
     94     if (ref_ret != MBEDTLS_ERR_ASN1_BUF_TOO_SMALL) {
     95         my_ret = mbedtls_pkcs12_pbe(&pbe_params, MBEDTLS_PKCS12_PBE_ENCRYPT, cipher_alg,
     96                                     md_alg, pw->x, pw->len, data->x, data->len, my_out);
     97         TEST_EQUAL(my_ret, ref_ret);
     98     }
     99     if (ref_ret == 0) {
    100         ASSERT_COMPARE(my_out, ref_out->len,
    101                        ref_out->x, ref_out->len);
    102     }
    103 #endif
    104 
    105 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
    106 
    107     pbe_params.tag = params_tag;
    108     pbe_params.len = params_hex->len;
    109     pbe_params.p = params_hex->x;
    110 
    111     my_ret = mbedtls_pkcs12_pbe_ext(&pbe_params, MBEDTLS_PKCS12_PBE_ENCRYPT, cipher_alg,
    112                                     md_alg, pw->x, pw->len, data->x, data->len, my_out,
    113                                     outsize, &my_out_len);
    114     TEST_EQUAL(my_ret, ref_ret);
    115     if (ref_ret == 0) {
    116         ASSERT_COMPARE(my_out, my_out_len,
    117                        ref_out->x, ref_out->len);
    118     }
    119 #endif
    120 
    121 exit:
    122     mbedtls_free(my_out);
    123     MD_PSA_DONE();
    124 }
    125 /* END_CASE */
    126 
    127 /* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C:MBEDTLS_CIPHER_C */
    128 void pkcs12_pbe_decrypt(int params_tag, int cipher, int md, data_t *params_hex, data_t *pw,
    129                         data_t *data, int outsize, int ref_ret, data_t *ref_out)
    130 {
    131     int my_ret;
    132     mbedtls_asn1_buf pbe_params;
    133     unsigned char *my_out = NULL;
    134     mbedtls_cipher_type_t cipher_alg = (mbedtls_cipher_type_t) cipher;
    135     mbedtls_md_type_t md_alg = (mbedtls_md_type_t) md;
    136 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
    137     size_t my_out_len = 0;
    138 #endif
    139 
    140     MD_PSA_INIT();
    141 
    142     TEST_CALLOC(my_out, outsize);
    143 
    144     pbe_params.tag = params_tag;
    145     pbe_params.len = params_hex->len;
    146     pbe_params.p = params_hex->x;
    147 
    148 #if defined(MBEDTLS_TEST_DEPRECATED)
    149     if (ref_ret != MBEDTLS_ERR_ASN1_BUF_TOO_SMALL) {
    150         my_ret = mbedtls_pkcs12_pbe(&pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT, cipher_alg,
    151                                     md_alg, pw->x, pw->len, data->x, data->len, my_out);
    152         TEST_EQUAL(my_ret, ref_ret);
    153     }
    154 
    155     if (ref_ret == 0) {
    156         ASSERT_COMPARE(my_out, ref_out->len,
    157                        ref_out->x, ref_out->len);
    158     }
    159 #endif
    160 
    161 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
    162 
    163     pbe_params.tag = params_tag;
    164     pbe_params.len = params_hex->len;
    165     pbe_params.p = params_hex->x;
    166 
    167     my_ret = mbedtls_pkcs12_pbe_ext(&pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT, cipher_alg,
    168                                     md_alg, pw->x, pw->len, data->x, data->len, my_out,
    169                                     outsize, &my_out_len);
    170     TEST_EQUAL(my_ret, ref_ret);
    171     if (ref_ret == 0) {
    172         ASSERT_COMPARE(my_out, my_out_len,
    173                        ref_out->x, ref_out->len);
    174     }
    175 #endif
    176 
    177 exit:
    178     mbedtls_free(my_out);
    179     MD_PSA_DONE();
    180 }
    181 /* END_CASE */