1/* BEGIN_HEADER */ 2#include "mbedtls/aria.h" 3 4/* Maximum size of data used by test vectors 5 * WARNING: to be adapted if and when adding larger test cases */ 6#define ARIA_MAX_DATASIZE 160 7 8/* Maximum sizes of hexified things */ 9#define ARIA_MAX_KEY_STR (2 * MBEDTLS_ARIA_MAX_KEYSIZE + 1) 10#define ARIA_BLOCK_STR (2 * MBEDTLS_ARIA_BLOCKSIZE + 1) 11#define ARIA_MAX_DATA_STR (2 * ARIA_MAX_DATASIZE + 1) 12/* END_HEADER */ 13 14/* BEGIN_DEPENDENCIES 15 * depends_on:MBEDTLS_ARIA_C 16 * END_DEPENDENCIES 17 */ 18 19/* BEGIN_CASE */ 20void aria_valid_param() 21{ 22 TEST_VALID_PARAM(mbedtls_aria_free(NULL)); 23} 24/* END_CASE */ 25 26/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */ 27void aria_invalid_param() 28{ 29 mbedtls_aria_context ctx; 30 unsigned char key[128 / 8] = { 0 }; 31 unsigned char input[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 32 unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 33 unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 34 size_t iv_off = 0; 35 36 ((void) iv_off); 37 ((void) iv); 38 39 TEST_INVALID_PARAM(mbedtls_aria_init(NULL)); 40 41 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 42 mbedtls_aria_setkey_enc(NULL, key, 43 sizeof(key))); 44 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 45 mbedtls_aria_setkey_enc(&ctx, NULL, 46 sizeof(key))); 47 48 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 49 mbedtls_aria_setkey_dec(NULL, key, 50 sizeof(key))); 51 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 52 mbedtls_aria_setkey_dec(&ctx, NULL, 53 sizeof(key))); 54 55 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 56 mbedtls_aria_crypt_ecb(NULL, input, output)); 57 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 58 mbedtls_aria_crypt_ecb(&ctx, NULL, output)); 59 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 60 mbedtls_aria_crypt_ecb(&ctx, input, NULL)); 61 62#if defined(MBEDTLS_CIPHER_MODE_CBC) 63 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 64 mbedtls_aria_crypt_cbc(NULL, 65 MBEDTLS_ARIA_ENCRYPT, 66 sizeof(input), 67 iv, 68 input, 69 output)); 70 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 71 mbedtls_aria_crypt_cbc(&ctx, 72 42 /* invalid mode */, 73 sizeof(input), 74 iv, 75 input, 76 output)); 77 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 78 mbedtls_aria_crypt_cbc(&ctx, 79 MBEDTLS_ARIA_ENCRYPT, 80 sizeof(input), 81 NULL, 82 input, 83 output)); 84 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 85 mbedtls_aria_crypt_cbc(&ctx, 86 MBEDTLS_ARIA_ENCRYPT, 87 sizeof(input), 88 iv, 89 NULL, 90 output)); 91 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 92 mbedtls_aria_crypt_cbc(&ctx, 93 MBEDTLS_ARIA_ENCRYPT, 94 sizeof(input), 95 iv, 96 input, 97 NULL)); 98#endif /* MBEDTLS_CIPHER_MODE_CBC */ 99 100#if defined(MBEDTLS_CIPHER_MODE_CFB) 101 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 102 mbedtls_aria_crypt_cfb128(NULL, 103 MBEDTLS_ARIA_ENCRYPT, 104 sizeof(input), 105 &iv_off, 106 iv, 107 input, 108 output)); 109 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 110 mbedtls_aria_crypt_cfb128(&ctx, 111 42, /* invalid mode */ 112 sizeof(input), 113 &iv_off, 114 iv, 115 input, 116 output)); 117 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 118 mbedtls_aria_crypt_cfb128(&ctx, 119 MBEDTLS_ARIA_ENCRYPT, 120 sizeof(input), 121 NULL, 122 iv, 123 input, 124 output)); 125 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 126 mbedtls_aria_crypt_cfb128(&ctx, 127 MBEDTLS_ARIA_ENCRYPT, 128 sizeof(input), 129 &iv_off, 130 NULL, 131 input, 132 output)); 133 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 134 mbedtls_aria_crypt_cfb128(&ctx, 135 MBEDTLS_ARIA_ENCRYPT, 136 sizeof(input), 137 &iv_off, 138 iv, 139 NULL, 140 output)); 141 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 142 mbedtls_aria_crypt_cfb128(&ctx, 143 MBEDTLS_ARIA_ENCRYPT, 144 sizeof(input), 145 &iv_off, 146 iv, 147 input, 148 NULL)); 149#endif /* MBEDTLS_CIPHER_MODE_CFB */ 150 151#if defined(MBEDTLS_CIPHER_MODE_CTR) 152 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 153 mbedtls_aria_crypt_ctr(NULL, 154 sizeof(input), 155 &iv_off, 156 iv, 157 iv, 158 input, 159 output)); 160 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 161 mbedtls_aria_crypt_ctr(&ctx, 162 sizeof(input), 163 NULL, 164 iv, 165 iv, 166 input, 167 output)); 168 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 169 mbedtls_aria_crypt_ctr(&ctx, 170 sizeof(input), 171 &iv_off, 172 NULL, 173 iv, 174 input, 175 output)); 176 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 177 mbedtls_aria_crypt_ctr(&ctx, 178 sizeof(input), 179 &iv_off, 180 iv, 181 NULL, 182 input, 183 output)); 184 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 185 mbedtls_aria_crypt_ctr(&ctx, 186 sizeof(input), 187 &iv_off, 188 iv, 189 iv, 190 NULL, 191 output)); 192 TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 193 mbedtls_aria_crypt_ctr(&ctx, 194 sizeof(input), 195 &iv_off, 196 iv, 197 iv, 198 input, 199 NULL)); 200#endif /* MBEDTLS_CIPHER_MODE_CTR */ 201 202exit: 203 return; 204 205} 206/* END_CASE */ 207 208/* BEGIN_CASE */ 209void aria_encrypt_ecb(data_t *key_str, data_t *src_str, 210 data_t *expected_output, int setkey_result) 211{ 212 unsigned char output[ARIA_MAX_DATASIZE]; 213 mbedtls_aria_context ctx; 214 size_t i; 215 216 memset(output, 0x00, sizeof(output)); 217 mbedtls_aria_init(&ctx); 218 219 TEST_ASSERT(mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8) 220 == setkey_result); 221 if (setkey_result == 0) { 222 for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) { 223 TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i, 224 output + i) == 0); 225 } 226 227 TEST_MEMORY_COMPARE(output, expected_output->len, 228 expected_output->x, expected_output->len); 229 } 230 231exit: 232 mbedtls_aria_free(&ctx); 233} 234/* END_CASE */ 235 236/* BEGIN_CASE */ 237void aria_decrypt_ecb(data_t *key_str, data_t *src_str, 238 data_t *expected_output, int setkey_result) 239{ 240 unsigned char output[ARIA_MAX_DATASIZE]; 241 mbedtls_aria_context ctx; 242 size_t i; 243 244 memset(output, 0x00, sizeof(output)); 245 mbedtls_aria_init(&ctx); 246 247 TEST_ASSERT(mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8) 248 == setkey_result); 249 if (setkey_result == 0) { 250 for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) { 251 TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i, 252 output + i) == 0); 253 } 254 255 TEST_MEMORY_COMPARE(output, expected_output->len, 256 expected_output->x, expected_output->len); 257 } 258 259exit: 260 mbedtls_aria_free(&ctx); 261} 262/* END_CASE */ 263 264/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 265void aria_encrypt_cbc(data_t *key_str, data_t *iv_str, 266 data_t *src_str, data_t *expected_output, 267 int cbc_result) 268{ 269 unsigned char output[ARIA_MAX_DATASIZE]; 270 mbedtls_aria_context ctx; 271 272 memset(output, 0x00, sizeof(output)); 273 mbedtls_aria_init(&ctx); 274 275 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 276 TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_ENCRYPT, 277 src_str->len, iv_str->x, src_str->x, 278 output) == cbc_result); 279 if (cbc_result == 0) { 280 TEST_MEMORY_COMPARE(output, expected_output->len, 281 expected_output->x, expected_output->len); 282 } 283 284exit: 285 mbedtls_aria_free(&ctx); 286} 287/* END_CASE */ 288 289/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 290void aria_decrypt_cbc(data_t *key_str, data_t *iv_str, 291 data_t *src_str, data_t *expected_output, 292 int cbc_result) 293{ 294 unsigned char output[ARIA_MAX_DATASIZE]; 295 mbedtls_aria_context ctx; 296 297 memset(output, 0x00, sizeof(output)); 298 mbedtls_aria_init(&ctx); 299 300 mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8); 301 TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_DECRYPT, 302 src_str->len, iv_str->x, src_str->x, 303 output) == cbc_result); 304 if (cbc_result == 0) { 305 TEST_MEMORY_COMPARE(output, expected_output->len, 306 expected_output->x, expected_output->len); 307 } 308 309exit: 310 mbedtls_aria_free(&ctx); 311} 312/* END_CASE */ 313 314/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 315void aria_encrypt_cfb128(data_t *key_str, data_t *iv_str, 316 data_t *src_str, data_t *expected_output, 317 int result) 318{ 319 unsigned char output[ARIA_MAX_DATASIZE]; 320 mbedtls_aria_context ctx; 321 size_t iv_offset = 0; 322 323 memset(output, 0x00, sizeof(output)); 324 mbedtls_aria_init(&ctx); 325 326 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 327 TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_ENCRYPT, 328 src_str->len, &iv_offset, 329 iv_str->x, src_str->x, output) 330 == result); 331 332 TEST_MEMORY_COMPARE(output, expected_output->len, 333 expected_output->x, expected_output->len); 334 335exit: 336 mbedtls_aria_free(&ctx); 337} 338/* END_CASE */ 339 340/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 341void aria_decrypt_cfb128(data_t *key_str, data_t *iv_str, 342 data_t *src_str, data_t *expected_output, 343 int result) 344{ 345 unsigned char output[ARIA_MAX_DATASIZE]; 346 mbedtls_aria_context ctx; 347 size_t iv_offset = 0; 348 349 memset(output, 0x00, sizeof(output)); 350 mbedtls_aria_init(&ctx); 351 352 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 353 TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_DECRYPT, 354 src_str->len, &iv_offset, 355 iv_str->x, src_str->x, output) 356 == result); 357 358 TEST_MEMORY_COMPARE(output, expected_output->len, 359 expected_output->x, expected_output->len); 360 361exit: 362 mbedtls_aria_free(&ctx); 363} 364/* END_CASE */ 365 366/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 367void aria_encrypt_ctr(data_t *key_str, data_t *iv_str, 368 data_t *src_str, data_t *expected_output, 369 int result) 370{ 371 unsigned char output[ARIA_MAX_DATASIZE]; 372 unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE]; 373 mbedtls_aria_context ctx; 374 size_t iv_offset = 0; 375 376 memset(output, 0x00, sizeof(output)); 377 mbedtls_aria_init(&ctx); 378 379 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 380 TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset, 381 iv_str->x, blk, src_str->x, output) 382 == result); 383 384 TEST_MEMORY_COMPARE(output, expected_output->len, 385 expected_output->x, expected_output->len); 386 387exit: 388 mbedtls_aria_free(&ctx); 389} 390/* END_CASE */ 391 392/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 393void aria_decrypt_ctr(data_t *key_str, data_t *iv_str, 394 data_t *src_str, data_t *expected_output, 395 int result) 396{ 397 unsigned char output[ARIA_MAX_DATASIZE]; 398 unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE]; 399 mbedtls_aria_context ctx; 400 size_t iv_offset = 0; 401 402 memset(output, 0x00, sizeof(output)); 403 mbedtls_aria_init(&ctx); 404 405 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 406 TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset, 407 iv_str->x, blk, src_str->x, output) 408 == result); 409 410 TEST_MEMORY_COMPARE(output, expected_output->len, 411 expected_output->x, expected_output->len); 412 413exit: 414 mbedtls_aria_free(&ctx); 415} 416/* END_CASE */ 417 418/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */ 419void aria_selftest() 420{ 421 TEST_ASSERT(mbedtls_aria_self_test(1) == 0); 422} 423/* END_CASE */ 424