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