TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / 95f869c9fb97ff641de68b0ce4ff9b51a709f78f / . / tests / suites / test_suite_ccm.function
blob: 1b3a25f0a4df4dbfe07c2bb0ac7ef19b95b6be5a [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,
Ronald Cronaea41df2020-06-26 14:33:03 +0200[diff] [blame]155 data_t * expected_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 {
Ronald Cronaea41df2020-06-26 14:33:03 +0200[diff] [blame]175 TEST_ASSERT( memcmp( msg->x, expected_msg->x, expected_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,
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]195 data_t *key, data_t *msg,
196 data_t *source_address, data_t *frame_counter,
197 int sec_level, data_t *add,
198 data_t *expected_result, int output_ret )
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]199{
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]200 unsigned char iv[13];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]201 unsigned char result[50];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]202 mbedtls_ccm_context ctx;
Gilles Peskinee8d7e6c2021-02-09 12:00:13 +0100[diff] [blame]203 size_t iv_len, tag_len;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]204 int ret;
205
206 mbedtls_ccm_init( &ctx );
207
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]208 memset( result, 0x00, sizeof( result ) );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]209
210 if( sec_level % 4 == 0)
211 tag_len = 0;
212 else
213 tag_len = 1 << ( sec_level % 4 + 1);
214
Gilles Peskinee8d7e6c2021-02-09 12:00:13 +0100[diff] [blame]215 TEST_ASSERT( source_address->len == 8 );
216 TEST_ASSERT( frame_counter->len == 4 );
217 memcpy( iv, source_address->x, source_address->len );
218 memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]219 iv[source_address->len + frame_counter->len] = sec_level;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]220 iv_len = sizeof( iv );
221
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]222 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id,
223 key->x, key->len * 8 ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]224
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]225 ret = mbedtls_ccm_star_encrypt_and_tag( &ctx, msg->len, iv, iv_len,
226 add->x, add->len, msg->x,
227 result, result + msg->len, tag_len );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]228
229 TEST_ASSERT( ret == output_ret );
230
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]231 TEST_ASSERT( memcmp( result,
232 expected_result->x, expected_result->len ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]233
234 /* Check we didn't write past the end */
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]235 TEST_ASSERT( result[expected_result->len] == 0 &&
236 result[expected_result->len + 1] == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]237
238exit:
239 mbedtls_ccm_free( &ctx );
240}
241/* END_CASE */
242
243/* BEGIN_CASE */
244void mbedtls_ccm_star_auth_decrypt( int cipher_id,
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]245 data_t *key, data_t *msg,
246 data_t *source_address, data_t *frame_counter,
247 int sec_level, data_t *add,
248 data_t *expected_result, int output_ret )
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]249{
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]250 unsigned char iv[13];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]251 unsigned char result[50];
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]252 mbedtls_ccm_context ctx;
Gilles Peskinee8d7e6c2021-02-09 12:00:13 +0100[diff] [blame]253 size_t iv_len, tag_len;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]254 int ret;
255
256 mbedtls_ccm_init( &ctx );
257
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]258 memset( iv, 0x00, sizeof( iv ) );
Ronald Cron1d5ef292020-06-25 14:47:40 +0200[diff] [blame]259 memset( result, '+', sizeof( result ) );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]260
261 if( sec_level % 4 == 0)
262 tag_len = 0;
263 else
264 tag_len = 1 << ( sec_level % 4 + 1);
265
Gilles Peskinee8d7e6c2021-02-09 12:00:13 +0100[diff] [blame]266 TEST_ASSERT( source_address->len == 8 );
267 TEST_ASSERT( frame_counter->len == 4 );
268 memcpy( iv, source_address->x, source_address->len );
269 memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]270 iv[source_address->len + frame_counter->len] = sec_level;
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]271 iv_len = sizeof( iv );
272
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]273 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]274
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]275 ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg->len - tag_len, iv, iv_len,
276 add->x, add->len, msg->x, result,
277 msg->x + msg->len - tag_len, tag_len );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]278
279 TEST_ASSERT( ret == output_ret );
280
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]281 TEST_ASSERT( memcmp( result, expected_result->x,
282 expected_result->len ) == 0 );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]283
284 /* Check we didn't write past the end (where the original tag is) */
Ronald Cron14a56452020-06-25 09:03:34 +0200[diff] [blame]285 TEST_ASSERT( ( msg->len + 2 ) <= sizeof( result ) );
286 TEST_ASSERT( result[msg->len] == '+' );
287 TEST_ASSERT( result[msg->len + 1] == '+' );
Darryl Green0daf4ca2018-05-29 14:12:26 +0100[diff] [blame]288
289exit:
290 mbedtls_ccm_free( &ctx );
291}
292/* END_CASE */
k-stachowiak26d365e2018-12-11 12:22:16 +0100[diff] [blame]293
294/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
295void ccm_invalid_param( )
296{
297 struct mbedtls_ccm_context ctx;
298 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
299 mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
300 int valid_len = sizeof(valid_buffer);
301 int valid_bitlen = valid_len * 8;
302
303 mbedtls_ccm_init( &ctx );
304
305 /* mbedtls_ccm_init() */
306 TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
307
308 /* mbedtls_ccm_setkey() */
309 TEST_INVALID_PARAM_RET(
310 MBEDTLS_ERR_CCM_BAD_INPUT,
311 mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
312 TEST_INVALID_PARAM_RET(
313 MBEDTLS_ERR_CCM_BAD_INPUT,
314 mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
315
316 /* mbedtls_ccm_encrypt_and_tag() */
317 TEST_INVALID_PARAM_RET(
318 MBEDTLS_ERR_CCM_BAD_INPUT,
319 mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
320 valid_buffer, valid_len,
321 valid_buffer, valid_len,
322 valid_buffer, valid_buffer,
323 valid_buffer, valid_len ) );
324 TEST_INVALID_PARAM_RET(
325 MBEDTLS_ERR_CCM_BAD_INPUT,
326 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
327 NULL, valid_len,
328 valid_buffer, valid_len,
329 valid_buffer, valid_buffer,
330 valid_buffer, valid_len ) );
331 TEST_INVALID_PARAM_RET(
332 MBEDTLS_ERR_CCM_BAD_INPUT,
333 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
334 valid_buffer, valid_len,
335 NULL, valid_len,
336 valid_buffer, valid_buffer,
337 valid_buffer, valid_len ) );
338 TEST_INVALID_PARAM_RET(
339 MBEDTLS_ERR_CCM_BAD_INPUT,
340 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
341 valid_buffer, valid_len,
342 valid_buffer, valid_len,
343 NULL, valid_buffer,
344 valid_buffer, valid_len ) );
345 TEST_INVALID_PARAM_RET(
346 MBEDTLS_ERR_CCM_BAD_INPUT,
347 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
348 valid_buffer, valid_len,
349 valid_buffer, valid_len,
350 valid_buffer, NULL,
351 valid_buffer, valid_len ) );
352 TEST_INVALID_PARAM_RET(
353 MBEDTLS_ERR_CCM_BAD_INPUT,
354 mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
355 valid_buffer, valid_len,
356 valid_buffer, valid_len,
357 valid_buffer, valid_buffer,
358 NULL, valid_len ) );
359
360 /* mbedtls_ccm_star_encrypt_and_tag() */
361 TEST_INVALID_PARAM_RET(
362 MBEDTLS_ERR_CCM_BAD_INPUT,
363 mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
364 valid_buffer, valid_len,
365 valid_buffer, valid_len,
366 valid_buffer, valid_buffer,
367 valid_buffer, valid_len) );
368 TEST_INVALID_PARAM_RET(
369 MBEDTLS_ERR_CCM_BAD_INPUT,
370 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
371 NULL, valid_len,
372 valid_buffer, valid_len,
373 valid_buffer, valid_buffer,
374 valid_buffer, valid_len ) );
375 TEST_INVALID_PARAM_RET(
376 MBEDTLS_ERR_CCM_BAD_INPUT,
377 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
378 valid_buffer, valid_len,
379 NULL, valid_len,
380 valid_buffer, valid_buffer,
381 valid_buffer, valid_len ) );
382 TEST_INVALID_PARAM_RET(
383 MBEDTLS_ERR_CCM_BAD_INPUT,
384 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
385 valid_buffer, valid_len,
386 valid_buffer, valid_len,
387 NULL, valid_buffer,
388 valid_buffer, valid_len ) );
389 TEST_INVALID_PARAM_RET(
390 MBEDTLS_ERR_CCM_BAD_INPUT,
391 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
392 valid_buffer, valid_len,
393 valid_buffer, valid_len,
394 valid_buffer, NULL,
395 valid_buffer, valid_len ) );
396 TEST_INVALID_PARAM_RET(
397 MBEDTLS_ERR_CCM_BAD_INPUT,
398 mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
399 valid_buffer, valid_len,
400 valid_buffer, valid_len,
401 valid_buffer, valid_buffer,
402 NULL, valid_len ) );
403
404 /* mbedtls_ccm_auth_decrypt() */
405 TEST_INVALID_PARAM_RET(
406 MBEDTLS_ERR_CCM_BAD_INPUT,
407 mbedtls_ccm_auth_decrypt( NULL, valid_len,
408 valid_buffer, valid_len,
409 valid_buffer, valid_len,
410 valid_buffer, valid_buffer,
411 valid_buffer, valid_len ) );
412 TEST_INVALID_PARAM_RET(
413 MBEDTLS_ERR_CCM_BAD_INPUT,
414 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
415 NULL, valid_len,
416 valid_buffer, valid_len,
417 valid_buffer, valid_buffer,
418 valid_buffer, valid_len ) );
419 TEST_INVALID_PARAM_RET(
420 MBEDTLS_ERR_CCM_BAD_INPUT,
421 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
422 valid_buffer, valid_len,
423 NULL, valid_len,
424 valid_buffer, valid_buffer,
425 valid_buffer, valid_len ) );
426 TEST_INVALID_PARAM_RET(
427 MBEDTLS_ERR_CCM_BAD_INPUT,
428 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
429 valid_buffer, valid_len,
430 valid_buffer, valid_len,
431 NULL, valid_buffer,
432 valid_buffer, valid_len ) );
433 TEST_INVALID_PARAM_RET(
434 MBEDTLS_ERR_CCM_BAD_INPUT,
435 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
436 valid_buffer, valid_len,
437 valid_buffer, valid_len,
438 valid_buffer, NULL,
439 valid_buffer, valid_len ) );
440 TEST_INVALID_PARAM_RET(
441 MBEDTLS_ERR_CCM_BAD_INPUT,
442 mbedtls_ccm_auth_decrypt( &ctx, valid_len,
443 valid_buffer, valid_len,
444 valid_buffer, valid_len,
445 valid_buffer, valid_buffer,
446 NULL, valid_len ) );
447
448 /* mbedtls_ccm_star_auth_decrypt() */
449 TEST_INVALID_PARAM_RET(
450 MBEDTLS_ERR_CCM_BAD_INPUT,
451 mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
452 valid_buffer, valid_len,
453 valid_buffer, valid_len,
454 valid_buffer, valid_buffer,
455 valid_buffer, valid_len ) );
456 TEST_INVALID_PARAM_RET(
457 MBEDTLS_ERR_CCM_BAD_INPUT,
458 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
459 NULL, valid_len,
460 valid_buffer, valid_len,
461 valid_buffer, valid_buffer,
462 valid_buffer, valid_len ) );
463 TEST_INVALID_PARAM_RET(
464 MBEDTLS_ERR_CCM_BAD_INPUT,
465 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
466 valid_buffer, valid_len,
467 NULL, valid_len,
468 valid_buffer, valid_buffer,
469 valid_buffer, valid_len ) );
470 TEST_INVALID_PARAM_RET(
471 MBEDTLS_ERR_CCM_BAD_INPUT,
472 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
473 valid_buffer, valid_len,
474 valid_buffer, valid_len,
475 NULL, valid_buffer,
476 valid_buffer, valid_len ) );
477 TEST_INVALID_PARAM_RET(
478 MBEDTLS_ERR_CCM_BAD_INPUT,
479 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
480 valid_buffer, valid_len,
481 valid_buffer, valid_len,
482 valid_buffer, NULL,
483 valid_buffer, valid_len ) );
484 TEST_INVALID_PARAM_RET(
485 MBEDTLS_ERR_CCM_BAD_INPUT,
486 mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
487 valid_buffer, valid_len,
488 valid_buffer, valid_len,
489 valid_buffer, valid_buffer,
490 NULL, valid_len ) );
491
k-stachowiak26d365e2018-12-11 12:22:16 +0100[diff] [blame]492exit:
493 mbedtls_ccm_free( &ctx );
494 return;
495}
496/* END_CASE */
k-stachowiakdd633592018-12-12 15:26:49 +0100[diff] [blame]497
498/* BEGIN_CASE */
499void ccm_valid_param( )
500{
501 TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
502exit:
503 return;
504}
505/* END_CASE */