test_suite_aria.function (8889B)
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 */ 20 void aria_invalid_param() 21 { 22 mbedtls_aria_context ctx; 23 unsigned char input[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 24 unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 25 unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE] = { 0 }; 26 size_t iv_off = 0; 27 28 ((void) iv_off); 29 ((void) iv); 30 ((void) ctx); 31 ((void) input); 32 ((void) output); 33 34 #if defined(MBEDTLS_CIPHER_MODE_CBC) 35 TEST_EQUAL(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 36 mbedtls_aria_crypt_cbc(&ctx, 37 42 /* invalid mode */, 38 sizeof(input), 39 iv, 40 input, 41 output)); 42 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 43 44 #if defined(MBEDTLS_CIPHER_MODE_CFB) 45 TEST_EQUAL(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA, 46 mbedtls_aria_crypt_cfb128(&ctx, 47 42, /* invalid mode */ 48 sizeof(input), 49 &iv_off, 50 iv, 51 input, 52 output)); 53 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 54 55 #if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB) 56 exit: 57 return; 58 #endif 59 60 } 61 /* END_CASE */ 62 63 /* BEGIN_CASE */ 64 void aria_encrypt_ecb(data_t *key_str, data_t *src_str, 65 data_t *expected_output, int setkey_result) 66 { 67 unsigned char output[ARIA_MAX_DATASIZE]; 68 mbedtls_aria_context ctx; 69 size_t i; 70 71 memset(output, 0x00, sizeof(output)); 72 mbedtls_aria_init(&ctx); 73 74 TEST_ASSERT(mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8) 75 == setkey_result); 76 if (setkey_result == 0) { 77 for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) { 78 TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i, 79 output + i) == 0); 80 } 81 82 TEST_MEMORY_COMPARE(output, expected_output->len, 83 expected_output->x, expected_output->len); 84 } 85 86 exit: 87 mbedtls_aria_free(&ctx); 88 } 89 /* END_CASE */ 90 91 /* BEGIN_CASE depends_on:!MBEDTLS_BLOCK_CIPHER_NO_DECRYPT */ 92 void aria_decrypt_ecb(data_t *key_str, data_t *src_str, 93 data_t *expected_output, int setkey_result) 94 { 95 unsigned char output[ARIA_MAX_DATASIZE]; 96 mbedtls_aria_context ctx; 97 size_t i; 98 99 memset(output, 0x00, sizeof(output)); 100 mbedtls_aria_init(&ctx); 101 102 TEST_ASSERT(mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8) 103 == setkey_result); 104 if (setkey_result == 0) { 105 for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) { 106 TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i, 107 output + i) == 0); 108 } 109 110 TEST_MEMORY_COMPARE(output, expected_output->len, 111 expected_output->x, expected_output->len); 112 } 113 114 exit: 115 mbedtls_aria_free(&ctx); 116 } 117 /* END_CASE */ 118 119 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 120 void aria_encrypt_cbc(data_t *key_str, data_t *iv_str, 121 data_t *src_str, data_t *expected_output, 122 int cbc_result) 123 { 124 unsigned char output[ARIA_MAX_DATASIZE]; 125 mbedtls_aria_context ctx; 126 127 memset(output, 0x00, sizeof(output)); 128 mbedtls_aria_init(&ctx); 129 130 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 131 TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_ENCRYPT, 132 src_str->len, iv_str->x, src_str->x, 133 output) == cbc_result); 134 if (cbc_result == 0) { 135 TEST_MEMORY_COMPARE(output, expected_output->len, 136 expected_output->x, expected_output->len); 137 } 138 139 exit: 140 mbedtls_aria_free(&ctx); 141 } 142 /* END_CASE */ 143 144 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */ 145 void aria_decrypt_cbc(data_t *key_str, data_t *iv_str, 146 data_t *src_str, data_t *expected_output, 147 int cbc_result) 148 { 149 unsigned char output[ARIA_MAX_DATASIZE]; 150 mbedtls_aria_context ctx; 151 152 memset(output, 0x00, sizeof(output)); 153 mbedtls_aria_init(&ctx); 154 155 mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8); 156 TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_DECRYPT, 157 src_str->len, iv_str->x, src_str->x, 158 output) == cbc_result); 159 if (cbc_result == 0) { 160 TEST_MEMORY_COMPARE(output, expected_output->len, 161 expected_output->x, expected_output->len); 162 } 163 164 exit: 165 mbedtls_aria_free(&ctx); 166 } 167 /* END_CASE */ 168 169 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 170 void aria_encrypt_cfb128(data_t *key_str, data_t *iv_str, 171 data_t *src_str, data_t *expected_output, 172 int result) 173 { 174 unsigned char output[ARIA_MAX_DATASIZE]; 175 mbedtls_aria_context ctx; 176 size_t iv_offset = 0; 177 178 memset(output, 0x00, sizeof(output)); 179 mbedtls_aria_init(&ctx); 180 181 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 182 TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_ENCRYPT, 183 src_str->len, &iv_offset, 184 iv_str->x, src_str->x, output) 185 == result); 186 187 TEST_MEMORY_COMPARE(output, expected_output->len, 188 expected_output->x, expected_output->len); 189 190 exit: 191 mbedtls_aria_free(&ctx); 192 } 193 /* END_CASE */ 194 195 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */ 196 void aria_decrypt_cfb128(data_t *key_str, data_t *iv_str, 197 data_t *src_str, data_t *expected_output, 198 int result) 199 { 200 unsigned char output[ARIA_MAX_DATASIZE]; 201 mbedtls_aria_context ctx; 202 size_t iv_offset = 0; 203 204 memset(output, 0x00, sizeof(output)); 205 mbedtls_aria_init(&ctx); 206 207 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 208 TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_DECRYPT, 209 src_str->len, &iv_offset, 210 iv_str->x, src_str->x, output) 211 == result); 212 213 TEST_MEMORY_COMPARE(output, expected_output->len, 214 expected_output->x, expected_output->len); 215 216 exit: 217 mbedtls_aria_free(&ctx); 218 } 219 /* END_CASE */ 220 221 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 222 void aria_encrypt_ctr(data_t *key_str, data_t *iv_str, 223 data_t *src_str, data_t *expected_output, 224 int result) 225 { 226 unsigned char output[ARIA_MAX_DATASIZE]; 227 unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE]; 228 mbedtls_aria_context ctx; 229 size_t iv_offset = 0; 230 231 memset(output, 0x00, sizeof(output)); 232 mbedtls_aria_init(&ctx); 233 234 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 235 TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset, 236 iv_str->x, blk, src_str->x, output) 237 == result); 238 239 TEST_MEMORY_COMPARE(output, expected_output->len, 240 expected_output->x, expected_output->len); 241 242 exit: 243 mbedtls_aria_free(&ctx); 244 } 245 /* END_CASE */ 246 247 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */ 248 void aria_decrypt_ctr(data_t *key_str, data_t *iv_str, 249 data_t *src_str, data_t *expected_output, 250 int result) 251 { 252 unsigned char output[ARIA_MAX_DATASIZE]; 253 unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE]; 254 mbedtls_aria_context ctx; 255 size_t iv_offset = 0; 256 257 memset(output, 0x00, sizeof(output)); 258 mbedtls_aria_init(&ctx); 259 260 mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8); 261 TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset, 262 iv_str->x, blk, src_str->x, output) 263 == result); 264 265 TEST_MEMORY_COMPARE(output, expected_output->len, 266 expected_output->x, expected_output->len); 267 268 exit: 269 mbedtls_aria_free(&ctx); 270 } 271 /* END_CASE */ 272 273 /* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */ 274 void aria_selftest() 275 { 276 TEST_ASSERT(mbedtls_aria_self_test(1) == 0); 277 } 278 /* END_CASE */