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_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)
56exit:
57    return;
58#endif
59
60}
61/* END_CASE */
62
63/* BEGIN_CASE */
64void 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
86exit:
87    mbedtls_aria_free(&ctx);
88}
89/* END_CASE */
90
91/* BEGIN_CASE depends_on:!MBEDTLS_BLOCK_CIPHER_NO_DECRYPT */
92void 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
114exit:
115    mbedtls_aria_free(&ctx);
116}
117/* END_CASE */
118
119/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
120void 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
139exit:
140    mbedtls_aria_free(&ctx);
141}
142/* END_CASE */
143
144/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
145void 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
164exit:
165    mbedtls_aria_free(&ctx);
166}
167/* END_CASE */
168
169/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
170void 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
190exit:
191    mbedtls_aria_free(&ctx);
192}
193/* END_CASE */
194
195/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
196void 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
216exit:
217    mbedtls_aria_free(&ctx);
218}
219/* END_CASE */
220
221/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
222void 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
242exit:
243    mbedtls_aria_free(&ctx);
244}
245/* END_CASE */
246
247/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
248void 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
268exit:
269    mbedtls_aria_free(&ctx);
270}
271/* END_CASE */
272
273/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
274void aria_selftest()
275{
276    TEST_ASSERT(mbedtls_aria_self_test(1) == 0);
277}
278/* END_CASE */
279