• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/* BEGIN_HEADER */
2#include "mbedtls/cipher.h"
3#include "mbedtls/cmac.h"
4/* END_HEADER */
5
6/* BEGIN_DEPENDENCIES
7 * depends_on:MBEDTLS_CMAC_C
8 * END_DEPENDENCIES
9 */
10
11/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
12void mbedtls_cmac_self_test()
13{
14    TEST_ASSERT(mbedtls_cmac_self_test(1) == 0);
15}
16/* END_CASE */
17
18/* BEGIN_CASE */
19void mbedtls_cmac_null_args()
20{
21    mbedtls_cipher_context_t ctx;
22    const mbedtls_cipher_info_t *cipher_info;
23    unsigned char test_key[MBEDTLS_CIPHER_BLKSIZE_MAX];
24    unsigned char test_data[MBEDTLS_CIPHER_BLKSIZE_MAX];
25    unsigned char test_output[MBEDTLS_CIPHER_BLKSIZE_MAX];
26
27    mbedtls_cipher_init(&ctx);
28
29    /* Test NULL cipher info */
30    TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx, test_data, 16) ==
31                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
32
33    cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB);
34    TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
35
36    TEST_ASSERT(mbedtls_cipher_cmac_starts(NULL, test_key, 128) ==
37                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
38
39    TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx, NULL, 128) ==
40                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
41
42    TEST_ASSERT(mbedtls_cipher_cmac_update(NULL, test_data, 16) ==
43                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
44
45    TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx, NULL, 16) ==
46                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
47
48    TEST_ASSERT(mbedtls_cipher_cmac_finish(NULL, test_output) ==
49                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
50
51    TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, NULL) ==
52                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
53
54    TEST_ASSERT(mbedtls_cipher_cmac_reset(NULL) ==
55                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
56
57    TEST_ASSERT(mbedtls_cipher_cmac(NULL,
58                                    test_key, 128,
59                                    test_data, 16,
60                                    test_output) ==
61                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
62
63    TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
64                                    NULL, 128,
65                                    test_data, 16,
66                                    test_output) ==
67                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
68
69    TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
70                                    test_key, 128,
71                                    NULL, 16,
72                                    test_output) ==
73                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
74
75    TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
76                                    test_key, 128,
77                                    test_data, 16,
78                                    NULL) ==
79                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
80#if defined(MBEDTLS_AES_C)
81    TEST_ASSERT(mbedtls_aes_cmac_prf_128(NULL, 16,
82                                         test_data, 16,
83                                         test_output) ==
84                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
85
86    TEST_ASSERT(mbedtls_aes_cmac_prf_128(test_key, 16,
87                                         NULL, 16,
88                                         test_output) ==
89                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
90
91    TEST_ASSERT(mbedtls_aes_cmac_prf_128(test_key, 16,
92                                         test_data, 16,
93                                         NULL) ==
94                MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
95#endif
96exit:
97    mbedtls_cipher_free(&ctx);
98}
99/* END_CASE */
100
101/* BEGIN_CASE */
102void mbedtls_cmac_setkey(int cipher_type, int key_size, int result)
103{
104    const mbedtls_cipher_info_t *cipher_info;
105    unsigned char key[32];
106    unsigned char buf[16];
107    unsigned char tmp[16];
108
109    memset(key, 0x2A, sizeof(key));
110    TEST_ASSERT((unsigned) key_size <= 8 * sizeof(key));
111
112    TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
113                != NULL);
114
115    memset(buf, 0x2A, sizeof(buf));
116    TEST_ASSERT((result == mbedtls_cipher_cmac(cipher_info, key, key_size,
117                                               buf, 16, tmp)) != 0);
118}
119/* END_CASE */
120
121/* BEGIN_CASE */
122void mbedtls_cmac_multiple_blocks(int cipher_type, data_t *key,
123                                  int keybits, int block_size,
124                                  data_t *block1, int block1_len,
125                                  data_t *block2, int block2_len,
126                                  data_t *block3, int block3_len,
127                                  data_t *block4, int block4_len,
128                                  data_t *expected_result)
129{
130    const mbedtls_cipher_info_t *cipher_info;
131    mbedtls_cipher_context_t ctx;
132    unsigned char output[MBEDTLS_CIPHER_BLKSIZE_MAX];
133
134    /* Convert the test parameters to binary data */
135
136    mbedtls_cipher_init(&ctx);
137
138    /* Validate the test inputs */
139    TEST_ASSERT(block1_len <= 100);
140    TEST_ASSERT(block2_len <= 100);
141    TEST_ASSERT(block3_len <= 100);
142    TEST_ASSERT(block4_len <= 100);
143
144    /* Set up */
145    TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
146                != NULL);
147
148    TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
149
150    TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx,
151                                           (const unsigned char *) key->x,
152                                           keybits) == 0);
153
154    /* Multiple partial and complete blocks. A negative length means skip the
155     * update operation */
156    if (block1_len >= 0) {
157        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
158                                               (unsigned char *) block1->x,
159                                               block1_len) == 0);
160    }
161
162    if (block2_len >= 0) {
163        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
164                                               (unsigned char *) block2->x,
165                                               block2_len) == 0);
166    }
167
168    if (block3_len >= 0) {
169        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
170                                               (unsigned char *) block3->x,
171                                               block3_len) == 0);
172    }
173
174    if (block4_len >= 0) {
175        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
176                                               (unsigned char *) block4->x,
177                                               block4_len) == 0);
178    }
179
180    TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
181
182    TEST_ASSERT(memcmp(output, expected_result->x, block_size)  == 0);
183
184exit:
185    mbedtls_cipher_free(&ctx);
186}
187/* END_CASE */
188
189/* BEGIN_CASE */
190void mbedtls_cmac_multiple_operations_same_key(int cipher_type,
191                                               data_t *key, int keybits,
192                                               int block_size,
193                                               data_t *block_a1,
194                                               int block_a1_len,
195                                               data_t *block_a2,
196                                               int block_a2_len,
197                                               data_t *block_a3,
198                                               int block_a3_len,
199                                               data_t *expected_result_a,
200                                               data_t *block_b1,
201                                               int block_b1_len,
202                                               data_t *block_b2,
203                                               int block_b2_len,
204                                               data_t *block_b3,
205                                               int block_b3_len,
206                                               data_t *expected_result_b
207                                               )
208{
209    const mbedtls_cipher_info_t *cipher_info;
210    mbedtls_cipher_context_t ctx;
211    unsigned char output[MBEDTLS_CIPHER_BLKSIZE_MAX];
212
213    /* Convert the test parameters to binary data */
214
215
216
217    mbedtls_cipher_init(&ctx);
218
219    /* Validate the test inputs */
220    TEST_ASSERT(block_a1_len <= 100);
221    TEST_ASSERT(block_a2_len <= 100);
222    TEST_ASSERT(block_a3_len <= 100);
223
224    TEST_ASSERT(block_b1_len <= 100);
225    TEST_ASSERT(block_b2_len <= 100);
226    TEST_ASSERT(block_b3_len <= 100);
227
228    /* Set up */
229    TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
230                != NULL);
231
232    TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
233
234    TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx,
235                                           (const unsigned char *) key->x,
236                                           keybits) == 0);
237
238    /* Sequence A */
239
240    /* Multiple partial and complete blocks. A negative length means skip the
241     * update operation */
242    if (block_a1_len >= 0) {
243        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
244                                               (unsigned char *) block_a1->x,
245                                               block_a1_len) == 0);
246    }
247
248    if (block_a2_len >= 0) {
249        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
250                                               (unsigned char *) block_a2->x,
251                                               block_a2_len) == 0);
252    }
253
254    if (block_a3_len >= 0) {
255        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
256                                               (unsigned char *) block_a3->x,
257                                               block_a3_len) == 0);
258    }
259
260    TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
261
262    TEST_ASSERT(memcmp(output, expected_result_a->x, block_size)  == 0);
263
264    TEST_ASSERT(mbedtls_cipher_cmac_reset(&ctx) == 0);
265
266    /* Sequence B */
267
268    /* Multiple partial and complete blocks. A negative length means skip the
269     * update operation */
270    if (block_b1_len >= 0) {
271        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
272                                               (unsigned char *) block_b1->x,
273                                               block_b1_len) == 0);
274    }
275
276    if (block_b2_len >= 0) {
277        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
278                                               (unsigned char *) block_b2->x,
279                                               block_b2_len) == 0);
280    }
281
282    if (block_b3_len >= 0) {
283        TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
284                                               (unsigned char *) block_b3->x,
285                                               block_b3_len) == 0);
286    }
287
288    TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
289
290    TEST_ASSERT(memcmp(output, expected_result_b->x, block_size)  == 0);
291
292exit:
293    mbedtls_cipher_free(&ctx);
294}
295/* END_CASE */
296