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