TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / 5b13a86e11e2d1153007e88c0ca087e8bfdba536 / . / tests / suites / test_suite_ccm.function
blob: 01e1a173be00bc88587105ef590a5bffae9c56ef [file] [log] [blame]
Manuel Pégourié-Gonnarda6916fa2014-05-02 15:17:29 +0200[diff] [blame]1/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +0000[diff] [blame]2#include "mbedtls/ccm.h"
Manuel Pégourié-Gonnarda6916fa2014-05-02 15:17:29 +0200[diff] [blame]3/* END_HEADER */
4
5/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]6 * depends_on:MBEDTLS_CCM_C
Manuel Pégourié-Gonnarda6916fa2014-05-02 15:17:29 +0200[diff] [blame]7 * END_DEPENDENCIES
8 */
9
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]10/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100[diff] [blame]11void mbedtls_ccm_self_test( )
Manuel Pégourié-Gonnarda6916fa2014-05-02 15:17:29 +0200[diff] [blame]12{
Andres AG93012e82016-09-09 09:10:28 +0100[diff] [blame]13 TEST_ASSERT( mbedtls_ccm_self_test( 1 ) == 0 );
Manuel Pégourié-Gonnarda6916fa2014-05-02 15:17:29 +0200[diff] [blame]14}
15/* END_CASE */
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]16
17/* BEGIN_CASE */
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]18void mbedtls_ccm_setkey( int cipher_id, int key_size, int result )
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]19{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]20 mbedtls_ccm_context ctx;
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]21 unsigned char key[32];
22 int ret;
23
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]24 mbedtls_ccm_init( &ctx );
25
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]26 memset( key, 0x2A, sizeof( key ) );
27 TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
28
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]29 ret = mbedtls_ccm_setkey( &ctx, cipher_id, key, key_size );
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]30 TEST_ASSERT( ret == result );
31
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]32exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]33 mbedtls_ccm_free( &ctx );
Manuel Pégourié-Gonnard9fe0d132014-05-06 12:12:45 +0200[diff] [blame]34}
35/* END_CASE */
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]36
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]37/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]38void ccm_lengths( int msg_len, int iv_len, int add_len, int tag_len, int res )
39{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]40 mbedtls_ccm_context ctx;
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]41 unsigned char key[16];
42 unsigned char msg[10];
43 unsigned char iv[14];
44 unsigned char add[10];
45 unsigned char out[10];
46 unsigned char tag[18];
47 int decrypt_ret;
48
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]49 mbedtls_ccm_init( &ctx );
50
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]51 memset( key, 0, sizeof( key ) );
52 memset( msg, 0, sizeof( msg ) );
53 memset( iv, 0, sizeof( iv ) );
54 memset( add, 0, sizeof( add ) );
55 memset( out, 0, sizeof( out ) );
56 memset( tag, 0, sizeof( tag ) );
57
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]58 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]59 key, 8 * sizeof( key ) ) == 0 );
60
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]61 TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg_len, iv, iv_len, add, add_len,
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]62 msg, out, tag, tag_len ) == res );
63
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]64 decrypt_ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len, iv, iv_len, add, add_len,
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]65 msg, out, tag, tag_len );
66
67 if( res == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]68 TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]69 else
70 TEST_ASSERT( decrypt_ret == res );
71
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]72exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]73 mbedtls_ccm_free( &ctx );
Manuel Pégourié-Gonnard87df5ba2014-05-06 18:07:24 +0200[diff] [blame]74}
75/* END_CASE */
76
Janos Follath95ab93d2018-05-14 14:32:41 +0100[diff] [blame]77/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
78void ccm_star_lengths( int msg_len, int iv_len, int add_len, int tag_len,
79 int res )
80{
81 mbedtls_ccm_context ctx;
82 unsigned char key[16];
83 unsigned char msg[10];
84 unsigned char iv[14];
85 unsigned char add[10];
86 unsigned char out[10];
87 unsigned char tag[18];
88 int decrypt_ret;
89
90 mbedtls_ccm_init( &ctx );
91
92 memset( key, 0, sizeof( key ) );
93 memset( msg, 0, sizeof( msg ) );
94 memset( iv, 0, sizeof( iv ) );
95 memset( add, 0, sizeof( add ) );
96 memset( out, 0, sizeof( out ) );
97 memset( tag, 0, sizeof( tag ) );
98
99 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
100 key, 8 * sizeof( key ) ) == 0 );
101
102 TEST_ASSERT( mbedtls_ccm_star_encrypt_and_tag( &ctx, msg_len, iv, iv_len,
103 add, add_len, msg, out, tag, tag_len ) == res );
104
105 decrypt_ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg_len, iv, iv_len, add,
106 add_len, msg, out, tag, tag_len );
107
108 if( res == 0 && tag_len != 0 )
109 TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
110 else
111 TEST_ASSERT( decrypt_ret == res );
112
113exit:
114 mbedtls_ccm_free( &ctx );
115}
116/* END_CASE */
117
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]118/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100[diff] [blame]119void mbedtls_ccm_encrypt_and_tag( int cipher_id, data_t * key,
120 data_t * msg, data_t * iv,
121 data_t * add, data_t * result )
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]122{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]123 mbedtls_ccm_context ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +0100[diff] [blame]124 size_t tag_len;
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]125 uint8_t * msg_n_tag = (uint8_t *)malloc( result->len + 2 );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]126
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]127 mbedtls_ccm_init( &ctx );
128
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]129 memset( msg_n_tag, 0, result->len + 2 );
130 memcpy( msg_n_tag, msg->x, msg->len );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]131
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]132 tag_len = result->len - msg->len;
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]133
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]134 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]135
Manuel Pégourié-Gonnard0f6b66d2014-05-07 14:43:46 +0200[diff] [blame]136 /* Test with input == output */
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]137 TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
138 msg_n_tag, msg_n_tag, msg_n_tag + msg->len, tag_len ) == 0 );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]139
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]140 TEST_ASSERT( memcmp( msg_n_tag, result->x, result->len ) == 0 );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]141
142 /* Check we didn't write past the end */
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]143 TEST_ASSERT( msg_n_tag[result->len] == 0 && msg_n_tag[result->len + 1] == 0 );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]144
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]145exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]146 mbedtls_ccm_free( &ctx );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100[diff] [blame]147 free( msg_n_tag );
Manuel Pégourié-Gonnard637eb3d2014-05-06 12:13:09 +0200[diff] [blame]148}
149/* END_CASE */
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]150
151/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100[diff] [blame]152void mbedtls_ccm_auth_decrypt( int cipher_id, data_t * key,
153 data_t * msg, data_t * iv,
154 data_t * add, int tag_len, int result,
155 data_t * hex_msg )
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]156{
Manuel Pégourié-Gonnard0f6b66d2014-05-07 14:43:46 +0200[diff] [blame]157 unsigned char tag[16];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]158 mbedtls_ccm_context ctx;
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]159
Manuel Pégourié-Gonnard6963ff02015-04-28 18:02:54 +0200[diff] [blame]160 mbedtls_ccm_init( &ctx );
161
Manuel Pégourié-Gonnard0f6b66d2014-05-07 14:43:46 +0200[diff] [blame]162 memset( tag, 0x00, sizeof( tag ) );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]163
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]164 msg->len -= tag_len;
165 memcpy( tag, msg->x + msg->len, tag_len );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]166
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]167 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]168
Manuel Pégourié-Gonnard0f6b66d2014-05-07 14:43:46 +0200[diff] [blame]169 /* Test with input == output */
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]170 TEST_ASSERT( mbedtls_ccm_auth_decrypt( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
Mohammad Azim Khancfd83422018-06-26 18:15:18 +0100[diff] [blame]171 msg->x, msg->x, msg->x + msg->len, tag_len ) == result );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]172
Mohammad Azim Khancfd83422018-06-26 18:15:18 +0100[diff] [blame]173 if( result == 0 )
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]174 {
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]175 TEST_ASSERT( memcmp( msg->x, hex_msg->x, hex_msg->len ) == 0 );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]176 }
177 else
178 {
179 size_t i;
180
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]181 for( i = 0; i < msg->len; i++ )
182 TEST_ASSERT( msg->x[i] == 0 );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]183 }
184
Manuel Pégourié-Gonnard0f6b66d2014-05-07 14:43:46 +0200[diff] [blame]185 /* Check we didn't write past the end (where the original tag is) */
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]186 TEST_ASSERT( memcmp( msg->x + msg->len, tag, tag_len ) == 0 );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]187
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]188exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]189 mbedtls_ccm_free( &ctx );
Manuel Pégourié-Gonnardce77d552014-05-06 18:06:52 +0200[diff] [blame]190}
191/* END_CASE */
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]192
193/* BEGIN_CASE */
194void mbedtls_ccm_star_encrypt_and_tag( int cipher_id,
195 char *key_hex, char *msg_hex,
196 char *source_address_hex, char *frame_counter_hex,
197 int sec_level, char *add_hex,
198 char *result_hex, int output_ret )
199{
200 unsigned char key[32];
201 unsigned char msg[50];
202 unsigned char iv[13];
203 unsigned char add[32];
204 unsigned char result[50];
205 unsigned char source_address[8];
206 unsigned char frame_counter[4];
207 mbedtls_ccm_context ctx;
208 size_t i, key_len, msg_len, iv_len, add_len, result_len, source_address_len, frame_counter_len, tag_len;
209 int ret;
210
211 mbedtls_ccm_init( &ctx );
212
213 memset( key, 0x00, sizeof( key ) );
214 memset( msg, 0x00, sizeof( msg ) );
215 memset( iv, 0x00, sizeof( iv ) );
216 memset( add, 0x00, sizeof( add ) );
217 memset( result, 0x00, sizeof( result ) );
218 memset( source_address, 0x00, sizeof( source_address ) );
219 memset( frame_counter, 0x00, sizeof( frame_counter ) );
220
Ronald Crona0c9ff32020-06-08 17:05:57 +0200[diff] [blame]221 key_len = mbedtls_test_unhexify( key, key_hex );
222 msg_len = mbedtls_test_unhexify( msg, msg_hex );
223 add_len = mbedtls_test_unhexify( add, add_hex );
224 result_len = mbedtls_test_unhexify( result, result_hex );
Ronald Cron5b13a862020-06-08 17:20:59 +0200[diff] [blame^]225 source_address_len = mbedtls_test_unhexify( source_address,
226 source_address_hex );
227 frame_counter_len = mbedtls_test_unhexify( frame_counter,
228 frame_counter_hex );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]229
230 if( sec_level % 4 == 0)
231 tag_len = 0;
232 else
233 tag_len = 1 << ( sec_level % 4 + 1);
234
235 for( i = 0; i < source_address_len; i++ )
236 iv[i] = source_address[i];
237
238 for( i = 0; i < frame_counter_len; i++ )
239 iv[source_address_len + i] = frame_counter[i];
240
241 iv[source_address_len + frame_counter_len] = sec_level;
242 iv_len = sizeof( iv );
243
244 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key, key_len * 8 ) == 0 );
245
246 ret = mbedtls_ccm_star_encrypt_and_tag( &ctx, msg_len, iv, iv_len,
247 add, add_len, msg, msg, msg + msg_len, tag_len );
248
249 TEST_ASSERT( ret == output_ret );
250
251 TEST_ASSERT( memcmp( msg, result, result_len ) == 0 );
252
253 /* Check we didn't write past the end */
254 TEST_ASSERT( msg[result_len] == 0 && msg[result_len + 1] == 0 );
255
256exit:
257 mbedtls_ccm_free( &ctx );
258}
259/* END_CASE */
260
261/* BEGIN_CASE */
262void mbedtls_ccm_star_auth_decrypt( int cipher_id,
263 char *key_hex, char *msg_hex,
264 char *source_address_hex, char *frame_counter_hex,
265 int sec_level, char *add_hex,
266 char *result_hex, int output_ret )
267{
268 unsigned char key[32];
269 unsigned char msg[50];
270 unsigned char iv[13];
271 unsigned char add[32];
272 unsigned char tag[16];
273 unsigned char result[50];
274 unsigned char source_address[8];
275 unsigned char frame_counter[4];
276 mbedtls_ccm_context ctx;
277 size_t i, key_len, msg_len, iv_len, add_len, tag_len, result_len, source_address_len, frame_counter_len;
278 int ret;
279
280 mbedtls_ccm_init( &ctx );
281
282 memset( key, 0x00, sizeof( key ) );
283 memset( msg, 0x00, sizeof( msg ) );
284 memset( iv, 0x00, sizeof( iv ) );
285 memset( add, 0x00, sizeof( add ) );
286 memset( result, 0x00, sizeof( result ) );
287 memset( source_address, 0x00, sizeof( source_address ) );
288 memset( frame_counter, 0x00, sizeof( frame_counter ) );
289 memset( tag, 0x00, sizeof( tag ) );
290
Ronald Crona0c9ff32020-06-08 17:05:57 +0200[diff] [blame]291 key_len = mbedtls_test_unhexify( key, key_hex );
292 msg_len = mbedtls_test_unhexify( msg, msg_hex );
293 add_len = mbedtls_test_unhexify( add, add_hex );
294 result_len = mbedtls_test_unhexify( result, result_hex );
Ronald Cron5b13a862020-06-08 17:20:59 +0200[diff] [blame^]295 source_address_len = mbedtls_test_unhexify( source_address,
296 source_address_hex );
297 frame_counter_len = mbedtls_test_unhexify( frame_counter,
298 frame_counter_hex );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]299
300 if( sec_level % 4 == 0)
301 tag_len = 0;
302 else
303 tag_len = 1 << ( sec_level % 4 + 1);
304
305 for( i = 0; i < source_address_len; i++ )
306 iv[i] = source_address[i];
307
308 for( i = 0; i < frame_counter_len; i++ )
309 iv[source_address_len + i] = frame_counter[i];
310
311 iv[source_address_len + frame_counter_len] = sec_level;
312 iv_len = sizeof( iv );
313
314 msg_len -= tag_len;
315 memcpy( tag, msg + msg_len, tag_len );
316
317 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key, key_len * 8 ) == 0 );
318
319 ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg_len, iv, iv_len,
320 add, add_len, msg, msg, msg + msg_len, tag_len );
321
322 TEST_ASSERT( ret == output_ret );
323
324 TEST_ASSERT( memcmp( msg, result, result_len ) == 0 );
325
326 /* Check we didn't write past the end (where the original tag is) */
327 TEST_ASSERT( memcmp( msg + msg_len, tag, tag_len ) == 0 );
328
329exit:
330 mbedtls_ccm_free( &ctx );
331}
332/* END_CASE */
k-stachowiak26d365e2018-12-11 12:22:16 +0100[diff] [blame]333
334/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
335void ccm_invalid_param( )
336{
337 struct mbedtls_ccm_context ctx;
338 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
339 mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
340 int valid_len = sizeof(valid_buffer);
341 int valid_bitlen = valid_len * 8;
342
343 mbedtls_ccm_init( &ctx );
344
345 /* mbedtls_ccm_init() */
346 TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
347
348 /* mbedtls_ccm_setkey() */
349 TEST_INVALID_PARAM_RET(
350 MBEDTLS_ERR_CCM_BAD_INPUT,
351 mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
352 TEST_INVALID_PARAM_RET(
353 MBEDTLS_ERR_CCM_BAD_INPUT,
354 mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
355
356 /* mbedtls_ccm_encrypt_and_tag() */
357 TEST_INVALID_PARAM_RET(
358 MBEDTLS_ERR_CCM_BAD_INPUT,
359 mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
360 valid_buffer, valid_len,
361 valid_buffer, valid_len,
362 valid_buffer, valid_buffer,
363 valid_buffer, valid_len ) );
364 TEST_INVALID_PARAM_RET(
365 MBEDTLS_ERR_CCM_BAD_INPUT,
366 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
367 NULL, valid_len,
368 valid_buffer, valid_len,
369 valid_buffer, valid_buffer,
370 valid_buffer, valid_len ) );
371 TEST_INVALID_PARAM_RET(
372 MBEDTLS_ERR_CCM_BAD_INPUT,
373 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
374 valid_buffer, valid_len,
375 NULL, valid_len,
376 valid_buffer, valid_buffer,
377 valid_buffer, valid_len ) );
378 TEST_INVALID_PARAM_RET(
379 MBEDTLS_ERR_CCM_BAD_INPUT,
380 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
381 valid_buffer, valid_len,
382 valid_buffer, valid_len,
383 NULL, valid_buffer,
384 valid_buffer, valid_len ) );
385 TEST_INVALID_PARAM_RET(
386 MBEDTLS_ERR_CCM_BAD_INPUT,
387 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
388 valid_buffer, valid_len,
389 valid_buffer, valid_len,
390 valid_buffer, NULL,
391 valid_buffer, valid_len ) );
392 TEST_INVALID_PARAM_RET(
393 MBEDTLS_ERR_CCM_BAD_INPUT,
394 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
395 valid_buffer, valid_len,
396 valid_buffer, valid_len,
397 valid_buffer, valid_buffer,
398 NULL, valid_len ) );
399
400 /* mbedtls_ccm_star_encrypt_and_tag() */
401 TEST_INVALID_PARAM_RET(
402 MBEDTLS_ERR_CCM_BAD_INPUT,
403 mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
404 valid_buffer, valid_len,
405 valid_buffer, valid_len,
406 valid_buffer, valid_buffer,
407 valid_buffer, valid_len) );
408 TEST_INVALID_PARAM_RET(
409 MBEDTLS_ERR_CCM_BAD_INPUT,
410 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
411 NULL, valid_len,
412 valid_buffer, valid_len,
413 valid_buffer, valid_buffer,
414 valid_buffer, valid_len ) );
415 TEST_INVALID_PARAM_RET(
416 MBEDTLS_ERR_CCM_BAD_INPUT,
417 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
418 valid_buffer, valid_len,
419 NULL, valid_len,
420 valid_buffer, valid_buffer,
421 valid_buffer, valid_len ) );
422 TEST_INVALID_PARAM_RET(
423 MBEDTLS_ERR_CCM_BAD_INPUT,
424 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
425 valid_buffer, valid_len,
426 valid_buffer, valid_len,
427 NULL, valid_buffer,
428 valid_buffer, valid_len ) );
429 TEST_INVALID_PARAM_RET(
430 MBEDTLS_ERR_CCM_BAD_INPUT,
431 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
432 valid_buffer, valid_len,
433 valid_buffer, valid_len,
434 valid_buffer, NULL,
435 valid_buffer, valid_len ) );
436 TEST_INVALID_PARAM_RET(
437 MBEDTLS_ERR_CCM_BAD_INPUT,
438 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
439 valid_buffer, valid_len,
440 valid_buffer, valid_len,
441 valid_buffer, valid_buffer,
442 NULL, valid_len ) );
443
444 /* mbedtls_ccm_auth_decrypt() */
445 TEST_INVALID_PARAM_RET(
446 MBEDTLS_ERR_CCM_BAD_INPUT,
447 mbedtls_ccm_auth_decrypt( NULL, valid_len,
448 valid_buffer, valid_len,
449 valid_buffer, valid_len,
450 valid_buffer, valid_buffer,
451 valid_buffer, valid_len ) );
452 TEST_INVALID_PARAM_RET(
453 MBEDTLS_ERR_CCM_BAD_INPUT,
454 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
455 NULL, valid_len,
456 valid_buffer, valid_len,
457 valid_buffer, valid_buffer,
458 valid_buffer, valid_len ) );
459 TEST_INVALID_PARAM_RET(
460 MBEDTLS_ERR_CCM_BAD_INPUT,
461 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
462 valid_buffer, valid_len,
463 NULL, valid_len,
464 valid_buffer, valid_buffer,
465 valid_buffer, valid_len ) );
466 TEST_INVALID_PARAM_RET(
467 MBEDTLS_ERR_CCM_BAD_INPUT,
468 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
469 valid_buffer, valid_len,
470 valid_buffer, valid_len,
471 NULL, valid_buffer,
472 valid_buffer, valid_len ) );
473 TEST_INVALID_PARAM_RET(
474 MBEDTLS_ERR_CCM_BAD_INPUT,
475 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
476 valid_buffer, valid_len,
477 valid_buffer, valid_len,
478 valid_buffer, NULL,
479 valid_buffer, valid_len ) );
480 TEST_INVALID_PARAM_RET(
481 MBEDTLS_ERR_CCM_BAD_INPUT,
482 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
483 valid_buffer, valid_len,
484 valid_buffer, valid_len,
485 valid_buffer, valid_buffer,
486 NULL, valid_len ) );
487
488 /* mbedtls_ccm_star_auth_decrypt() */
489 TEST_INVALID_PARAM_RET(
490 MBEDTLS_ERR_CCM_BAD_INPUT,
491 mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
492 valid_buffer, valid_len,
493 valid_buffer, valid_len,
494 valid_buffer, valid_buffer,
495 valid_buffer, valid_len ) );
496 TEST_INVALID_PARAM_RET(
497 MBEDTLS_ERR_CCM_BAD_INPUT,
498 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
499 NULL, valid_len,
500 valid_buffer, valid_len,
501 valid_buffer, valid_buffer,
502 valid_buffer, valid_len ) );
503 TEST_INVALID_PARAM_RET(
504 MBEDTLS_ERR_CCM_BAD_INPUT,
505 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
506 valid_buffer, valid_len,
507 NULL, valid_len,
508 valid_buffer, valid_buffer,
509 valid_buffer, valid_len ) );
510 TEST_INVALID_PARAM_RET(
511 MBEDTLS_ERR_CCM_BAD_INPUT,
512 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
513 valid_buffer, valid_len,
514 valid_buffer, valid_len,
515 NULL, valid_buffer,
516 valid_buffer, valid_len ) );
517 TEST_INVALID_PARAM_RET(
518 MBEDTLS_ERR_CCM_BAD_INPUT,
519 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
520 valid_buffer, valid_len,
521 valid_buffer, valid_len,
522 valid_buffer, NULL,
523 valid_buffer, valid_len ) );
524 TEST_INVALID_PARAM_RET(
525 MBEDTLS_ERR_CCM_BAD_INPUT,
526 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
527 valid_buffer, valid_len,
528 valid_buffer, valid_len,
529 valid_buffer, valid_buffer,
530 NULL, valid_len ) );
531
k-stachowiak26d365e2018-12-11 12:22:16 +0100[diff] [blame]532exit:
533 mbedtls_ccm_free( &ctx );
534 return;
535}
536/* END_CASE */
k-stachowiakdd633592018-12-12 15:26:49 +0100[diff] [blame]537
538/* BEGIN_CASE */
539void ccm_valid_param( )
540{
541 TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
542exit:
543 return;
544}
545/* END_CASE */