1/* BEGIN_HEADER */ 2#include "mbedtls/ccm.h" 3/* END_HEADER */ 4 5/* BEGIN_DEPENDENCIES 6 * depends_on:MBEDTLS_CCM_C 7 * END_DEPENDENCIES 8 */ 9 10/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */ 11void mbedtls_ccm_self_test( ) 12{ 13 TEST_ASSERT( mbedtls_ccm_self_test( 1 ) == 0 ); 14} 15/* END_CASE */ 16 17/* BEGIN_CASE */ 18void mbedtls_ccm_setkey( int cipher_id, int key_size, int result ) 19{ 20 mbedtls_ccm_context ctx; 21 unsigned char key[32]; 22 int ret; 23 24 mbedtls_ccm_init( &ctx ); 25 26 memset( key, 0x2A, sizeof( key ) ); 27 TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) ); 28 29 ret = mbedtls_ccm_setkey( &ctx, cipher_id, key, key_size ); 30 TEST_ASSERT( ret == result ); 31 32exit: 33 mbedtls_ccm_free( &ctx ); 34} 35/* END_CASE */ 36 37/* BEGIN_CASE depends_on:MBEDTLS_AES_C */ 38void ccm_lengths( int msg_len, int iv_len, int add_len, int tag_len, int res ) 39{ 40 mbedtls_ccm_context ctx; 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 49 mbedtls_ccm_init( &ctx ); 50 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 58 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, 59 key, 8 * sizeof( key ) ) == 0 ); 60 61 TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg_len, iv, iv_len, add, add_len, 62 msg, out, tag, tag_len ) == res ); 63 64 decrypt_ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len, iv, iv_len, add, add_len, 65 msg, out, tag, tag_len ); 66 67 if( res == 0 ) 68 TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED ); 69 else 70 TEST_ASSERT( decrypt_ret == res ); 71 72exit: 73 mbedtls_ccm_free( &ctx ); 74} 75/* END_CASE */ 76 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 118/* BEGIN_CASE */ 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 ) 122{ 123 mbedtls_ccm_context ctx; 124 size_t tag_len; 125 uint8_t * msg_n_tag = (uint8_t *)malloc( result->len + 2 ); 126 127 mbedtls_ccm_init( &ctx ); 128 129 memset( msg_n_tag, 0, result->len + 2 ); 130 memcpy( msg_n_tag, msg->x, msg->len ); 131 132 tag_len = result->len - msg->len; 133 134 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 ); 135 136 /* Test with input == output */ 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 ); 139 140 TEST_ASSERT( memcmp( msg_n_tag, result->x, result->len ) == 0 ); 141 142 /* Check we didn't write past the end */ 143 TEST_ASSERT( msg_n_tag[result->len] == 0 && msg_n_tag[result->len + 1] == 0 ); 144 145exit: 146 mbedtls_ccm_free( &ctx ); 147 free( msg_n_tag ); 148} 149/* END_CASE */ 150 151/* BEGIN_CASE */ 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 * expected_msg ) 156{ 157 unsigned char tag[16]; 158 mbedtls_ccm_context ctx; 159 160 mbedtls_ccm_init( &ctx ); 161 162 memset( tag, 0x00, sizeof( tag ) ); 163 164 msg->len -= tag_len; 165 memcpy( tag, msg->x + msg->len, tag_len ); 166 167 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 ); 168 169 /* Test with input == output */ 170 TEST_ASSERT( mbedtls_ccm_auth_decrypt( &ctx, msg->len, iv->x, iv->len, add->x, add->len, 171 msg->x, msg->x, msg->x + msg->len, tag_len ) == result ); 172 173 if( result == 0 ) 174 { 175 TEST_ASSERT( memcmp( msg->x, expected_msg->x, expected_msg->len ) == 0 ); 176 } 177 else 178 { 179 size_t i; 180 181 for( i = 0; i < msg->len; i++ ) 182 TEST_ASSERT( msg->x[i] == 0 ); 183 } 184 185 /* Check we didn't write past the end (where the original tag is) */ 186 TEST_ASSERT( memcmp( msg->x + msg->len, tag, tag_len ) == 0 ); 187 188exit: 189 mbedtls_ccm_free( &ctx ); 190} 191/* END_CASE */ 192 193/* BEGIN_CASE */ 194void mbedtls_ccm_star_encrypt_and_tag( int cipher_id, 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 ) 199{ 200 unsigned char iv[13]; 201 unsigned char result[50]; 202 mbedtls_ccm_context ctx; 203 size_t iv_len, tag_len; 204 int ret; 205 206 mbedtls_ccm_init( &ctx ); 207 208 memset( result, 0x00, sizeof( result ) ); 209 210 if( sec_level % 4 == 0) 211 tag_len = 0; 212 else 213 tag_len = 1 << ( sec_level % 4 + 1); 214 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 ); 219 iv[source_address->len + frame_counter->len] = sec_level; 220 iv_len = sizeof( iv ); 221 222 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, 223 key->x, key->len * 8 ) == 0 ); 224 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 ); 228 229 TEST_ASSERT( ret == output_ret ); 230 231 TEST_ASSERT( memcmp( result, 232 expected_result->x, expected_result->len ) == 0 ); 233 234 /* Check we didn't write past the end */ 235 TEST_ASSERT( result[expected_result->len] == 0 && 236 result[expected_result->len + 1] == 0 ); 237 238exit: 239 mbedtls_ccm_free( &ctx ); 240} 241/* END_CASE */ 242 243/* BEGIN_CASE */ 244void mbedtls_ccm_star_auth_decrypt( int cipher_id, 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 ) 249{ 250 unsigned char iv[13]; 251 unsigned char result[50]; 252 mbedtls_ccm_context ctx; 253 size_t iv_len, tag_len; 254 int ret; 255 256 mbedtls_ccm_init( &ctx ); 257 258 memset( iv, 0x00, sizeof( iv ) ); 259 memset( result, '+', sizeof( result ) ); 260 261 if( sec_level % 4 == 0) 262 tag_len = 0; 263 else 264 tag_len = 1 << ( sec_level % 4 + 1); 265 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 ); 270 iv[source_address->len + frame_counter->len] = sec_level; 271 iv_len = sizeof( iv ); 272 273 TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 ); 274 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 ); 278 279 TEST_ASSERT( ret == output_ret ); 280 281 TEST_ASSERT( memcmp( result, expected_result->x, 282 expected_result->len ) == 0 ); 283 284 /* Check we didn't write past the end (where the original tag is) */ 285 TEST_ASSERT( ( msg->len + 2 ) <= sizeof( result ) ); 286 TEST_ASSERT( result[msg->len] == '+' ); 287 TEST_ASSERT( result[msg->len + 1] == '+' ); 288 289exit: 290 mbedtls_ccm_free( &ctx ); 291} 292/* END_CASE */ 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 492exit: 493 mbedtls_ccm_free( &ctx ); 494 return; 495} 496/* END_CASE */ 497 498/* BEGIN_CASE */ 499void ccm_valid_param( ) 500{ 501 TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) ); 502exit: 503 return; 504} 505/* END_CASE */ 506