TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / c7ba5604811dc1f611e666c8863ee0fe2f4fef9f / . / tests / suites / test_suite_ccm.function
blob: 40ea278a6751736d6427b5ef24f9927d7c97b8a6 [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,
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]198 char *expected_result_hex, int output_ret )
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]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];
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]205 unsigned char expected_result[50];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]206 unsigned char source_address[8];
207 unsigned char frame_counter[4];
208 mbedtls_ccm_context ctx;
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]209 size_t i, key_len, msg_len, iv_len, add_len, expected_result_len, source_address_len, frame_counter_len, tag_len;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]210 int ret;
211
212 mbedtls_ccm_init( &ctx );
213
214 memset( key, 0x00, sizeof( key ) );
215 memset( msg, 0x00, sizeof( msg ) );
216 memset( iv, 0x00, sizeof( iv ) );
217 memset( add, 0x00, sizeof( add ) );
218 memset( result, 0x00, sizeof( result ) );
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]219 memset( expected_result, 0x00, sizeof( expected_result ) );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]220 memset( source_address, 0x00, sizeof( source_address ) );
221 memset( frame_counter, 0x00, sizeof( frame_counter ) );
222
Ronald Cron72d628f2020-06-08 17:05:57 +0200[diff] [blame]223 key_len = mbedtls_test_unhexify( key, key_hex );
224 msg_len = mbedtls_test_unhexify( msg, msg_hex );
225 add_len = mbedtls_test_unhexify( add, add_hex );
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]226 expected_result_len = mbedtls_test_unhexify( expected_result, expected_result_hex );
Ronald Cronff31eab2020-06-08 17:20:59 +0200[diff] [blame]227 source_address_len = mbedtls_test_unhexify( source_address,
228 source_address_hex );
229 frame_counter_len = mbedtls_test_unhexify( frame_counter,
230 frame_counter_hex );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]231
232 if( sec_level % 4 == 0)
233 tag_len = 0;
234 else
235 tag_len = 1 << ( sec_level % 4 + 1);
236
237 for( i = 0; i < source_address_len; i++ )
238 iv[i] = source_address[i];
239
240 for( i = 0; i < frame_counter_len; i++ )
241 iv[source_address_len + i] = frame_counter[i];
242
243 iv[source_address_len + frame_counter_len] = sec_level;
244 iv_len = sizeof( iv );
245
246 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key, key_len * 8 ) == 0 );
247
248 ret = mbedtls_ccm_star_encrypt_and_tag( &ctx, msg_len, iv, iv_len,
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]249 add, add_len, msg, result, result + msg_len, tag_len );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]250
251 TEST_ASSERT( ret == output_ret );
252
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]253 TEST_ASSERT( memcmp( result, expected_result, expected_result_len ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]254
255 /* Check we didn't write past the end */
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]256 TEST_ASSERT( result[expected_result_len] == 0 &&
257 result[expected_result_len + 1] == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]258
259exit:
260 mbedtls_ccm_free( &ctx );
261}
262/* END_CASE */
263
264/* BEGIN_CASE */
265void mbedtls_ccm_star_auth_decrypt( int cipher_id,
266 char *key_hex, char *msg_hex,
267 char *source_address_hex, char *frame_counter_hex,
268 int sec_level, char *add_hex,
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]269 char *expected_result_hex, int output_ret )
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]270{
271 unsigned char key[32];
272 unsigned char msg[50];
273 unsigned char iv[13];
274 unsigned char add[32];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]275 unsigned char result[50];
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]276 unsigned char expected_result[50];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]277 unsigned char source_address[8];
278 unsigned char frame_counter[4];
279 mbedtls_ccm_context ctx;
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]280 size_t i, key_len, msg_len, iv_len, add_len, tag_len, expected_result_len, source_address_len, frame_counter_len;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]281 int ret;
282
283 mbedtls_ccm_init( &ctx );
284
285 memset( key, 0x00, sizeof( key ) );
286 memset( msg, 0x00, sizeof( msg ) );
287 memset( iv, 0x00, sizeof( iv ) );
288 memset( add, 0x00, sizeof( add ) );
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]289 memset( result, '+', sizeof( result ) );
290 memset( expected_result, 0x00, sizeof( expected_result ) );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]291 memset( source_address, 0x00, sizeof( source_address ) );
292 memset( frame_counter, 0x00, sizeof( frame_counter ) );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]293
Ronald Cron72d628f2020-06-08 17:05:57 +0200[diff] [blame]294 key_len = mbedtls_test_unhexify( key, key_hex );
295 msg_len = mbedtls_test_unhexify( msg, msg_hex );
296 add_len = mbedtls_test_unhexify( add, add_hex );
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]297 expected_result_len = mbedtls_test_unhexify( expected_result, expected_result_hex );
Ronald Cronff31eab2020-06-08 17:20:59 +0200[diff] [blame]298 source_address_len = mbedtls_test_unhexify( source_address,
299 source_address_hex );
300 frame_counter_len = mbedtls_test_unhexify( frame_counter,
301 frame_counter_hex );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]302
303 if( sec_level % 4 == 0)
304 tag_len = 0;
305 else
306 tag_len = 1 << ( sec_level % 4 + 1);
307
308 for( i = 0; i < source_address_len; i++ )
309 iv[i] = source_address[i];
310
311 for( i = 0; i < frame_counter_len; i++ )
312 iv[source_address_len + i] = frame_counter[i];
313
314 iv[source_address_len + frame_counter_len] = sec_level;
315 iv_len = sizeof( iv );
316
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]317 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key, key_len * 8 ) == 0 );
318
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]319 ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg_len - tag_len, iv, iv_len,
320 add, add_len, msg, result, msg + msg_len - tag_len, tag_len );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]321
322 TEST_ASSERT( ret == output_ret );
323
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]324 TEST_ASSERT( memcmp( result, expected_result, expected_result_len ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]325
326 /* Check we didn't write past the end (where the original tag is) */
Ronald Cronc7ba5602020-06-25 14:47:40 +0200[diff] [blame^]327 TEST_ASSERT( ( msg_len + 2 ) <= sizeof( result ) );
328 TEST_EQUAL( result[msg_len], '+' );
329 TEST_EQUAL( result[msg_len + 1], '+' );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]330
331exit:
332 mbedtls_ccm_free( &ctx );
333}
334/* END_CASE */
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500[diff] [blame]335
336/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
337void ccm_invalid_param( )
338{
339 struct mbedtls_ccm_context ctx;
340 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
341 mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
342 int valid_len = sizeof(valid_buffer);
343 int valid_bitlen = valid_len * 8;
344
345 mbedtls_ccm_init( &ctx );
346
347 /* mbedtls_ccm_init() */
348 TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
349
350 /* mbedtls_ccm_setkey() */
351 TEST_INVALID_PARAM_RET(
352 MBEDTLS_ERR_CCM_BAD_INPUT,
353 mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
354 TEST_INVALID_PARAM_RET(
355 MBEDTLS_ERR_CCM_BAD_INPUT,
356 mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
357
358 /* mbedtls_ccm_encrypt_and_tag() */
359 TEST_INVALID_PARAM_RET(
360 MBEDTLS_ERR_CCM_BAD_INPUT,
361 mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
362 valid_buffer, valid_len,
363 valid_buffer, valid_len,
364 valid_buffer, valid_buffer,
365 valid_buffer, valid_len ) );
366 TEST_INVALID_PARAM_RET(
367 MBEDTLS_ERR_CCM_BAD_INPUT,
368 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
369 NULL, valid_len,
370 valid_buffer, valid_len,
371 valid_buffer, valid_buffer,
372 valid_buffer, valid_len ) );
373 TEST_INVALID_PARAM_RET(
374 MBEDTLS_ERR_CCM_BAD_INPUT,
375 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
376 valid_buffer, valid_len,
377 NULL, valid_len,
378 valid_buffer, valid_buffer,
379 valid_buffer, valid_len ) );
380 TEST_INVALID_PARAM_RET(
381 MBEDTLS_ERR_CCM_BAD_INPUT,
382 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
383 valid_buffer, valid_len,
384 valid_buffer, valid_len,
385 NULL, valid_buffer,
386 valid_buffer, valid_len ) );
387 TEST_INVALID_PARAM_RET(
388 MBEDTLS_ERR_CCM_BAD_INPUT,
389 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
390 valid_buffer, valid_len,
391 valid_buffer, valid_len,
392 valid_buffer, NULL,
393 valid_buffer, valid_len ) );
394 TEST_INVALID_PARAM_RET(
395 MBEDTLS_ERR_CCM_BAD_INPUT,
396 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
397 valid_buffer, valid_len,
398 valid_buffer, valid_len,
399 valid_buffer, valid_buffer,
400 NULL, valid_len ) );
401
402 /* mbedtls_ccm_star_encrypt_and_tag() */
403 TEST_INVALID_PARAM_RET(
404 MBEDTLS_ERR_CCM_BAD_INPUT,
405 mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
406 valid_buffer, valid_len,
407 valid_buffer, valid_len,
408 valid_buffer, valid_buffer,
409 valid_buffer, valid_len) );
410 TEST_INVALID_PARAM_RET(
411 MBEDTLS_ERR_CCM_BAD_INPUT,
412 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
413 NULL, valid_len,
414 valid_buffer, valid_len,
415 valid_buffer, valid_buffer,
416 valid_buffer, valid_len ) );
417 TEST_INVALID_PARAM_RET(
418 MBEDTLS_ERR_CCM_BAD_INPUT,
419 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
420 valid_buffer, valid_len,
421 NULL, valid_len,
422 valid_buffer, valid_buffer,
423 valid_buffer, valid_len ) );
424 TEST_INVALID_PARAM_RET(
425 MBEDTLS_ERR_CCM_BAD_INPUT,
426 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
427 valid_buffer, valid_len,
428 valid_buffer, valid_len,
429 NULL, valid_buffer,
430 valid_buffer, valid_len ) );
431 TEST_INVALID_PARAM_RET(
432 MBEDTLS_ERR_CCM_BAD_INPUT,
433 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
434 valid_buffer, valid_len,
435 valid_buffer, valid_len,
436 valid_buffer, NULL,
437 valid_buffer, valid_len ) );
438 TEST_INVALID_PARAM_RET(
439 MBEDTLS_ERR_CCM_BAD_INPUT,
440 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
441 valid_buffer, valid_len,
442 valid_buffer, valid_len,
443 valid_buffer, valid_buffer,
444 NULL, valid_len ) );
445
446 /* mbedtls_ccm_auth_decrypt() */
447 TEST_INVALID_PARAM_RET(
448 MBEDTLS_ERR_CCM_BAD_INPUT,
449 mbedtls_ccm_auth_decrypt( NULL, valid_len,
450 valid_buffer, valid_len,
451 valid_buffer, valid_len,
452 valid_buffer, valid_buffer,
453 valid_buffer, valid_len ) );
454 TEST_INVALID_PARAM_RET(
455 MBEDTLS_ERR_CCM_BAD_INPUT,
456 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
457 NULL, valid_len,
458 valid_buffer, valid_len,
459 valid_buffer, valid_buffer,
460 valid_buffer, valid_len ) );
461 TEST_INVALID_PARAM_RET(
462 MBEDTLS_ERR_CCM_BAD_INPUT,
463 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
464 valid_buffer, valid_len,
465 NULL, valid_len,
466 valid_buffer, valid_buffer,
467 valid_buffer, valid_len ) );
468 TEST_INVALID_PARAM_RET(
469 MBEDTLS_ERR_CCM_BAD_INPUT,
470 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
471 valid_buffer, valid_len,
472 valid_buffer, valid_len,
473 NULL, valid_buffer,
474 valid_buffer, valid_len ) );
475 TEST_INVALID_PARAM_RET(
476 MBEDTLS_ERR_CCM_BAD_INPUT,
477 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
478 valid_buffer, valid_len,
479 valid_buffer, valid_len,
480 valid_buffer, NULL,
481 valid_buffer, valid_len ) );
482 TEST_INVALID_PARAM_RET(
483 MBEDTLS_ERR_CCM_BAD_INPUT,
484 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
485 valid_buffer, valid_len,
486 valid_buffer, valid_len,
487 valid_buffer, valid_buffer,
488 NULL, valid_len ) );
489
490 /* mbedtls_ccm_star_auth_decrypt() */
491 TEST_INVALID_PARAM_RET(
492 MBEDTLS_ERR_CCM_BAD_INPUT,
493 mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
494 valid_buffer, valid_len,
495 valid_buffer, valid_len,
496 valid_buffer, valid_buffer,
497 valid_buffer, valid_len ) );
498 TEST_INVALID_PARAM_RET(
499 MBEDTLS_ERR_CCM_BAD_INPUT,
500 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
501 NULL, valid_len,
502 valid_buffer, valid_len,
503 valid_buffer, valid_buffer,
504 valid_buffer, valid_len ) );
505 TEST_INVALID_PARAM_RET(
506 MBEDTLS_ERR_CCM_BAD_INPUT,
507 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
508 valid_buffer, valid_len,
509 NULL, valid_len,
510 valid_buffer, valid_buffer,
511 valid_buffer, valid_len ) );
512 TEST_INVALID_PARAM_RET(
513 MBEDTLS_ERR_CCM_BAD_INPUT,
514 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
515 valid_buffer, valid_len,
516 valid_buffer, valid_len,
517 NULL, valid_buffer,
518 valid_buffer, valid_len ) );
519 TEST_INVALID_PARAM_RET(
520 MBEDTLS_ERR_CCM_BAD_INPUT,
521 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
522 valid_buffer, valid_len,
523 valid_buffer, valid_len,
524 valid_buffer, NULL,
525 valid_buffer, valid_len ) );
526 TEST_INVALID_PARAM_RET(
527 MBEDTLS_ERR_CCM_BAD_INPUT,
528 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
529 valid_buffer, valid_len,
530 valid_buffer, valid_len,
531 valid_buffer, valid_buffer,
532 NULL, valid_len ) );
533
534exit:
535 mbedtls_ccm_free( &ctx );
536 return;
537}
538/* END_CASE */
539
540/* BEGIN_CASE */
541void ccm_valid_param( )
542{
543 TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
544exit:
545 return;
546}
547/* END_CASE */