TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls.git / 8dd03cd1aa1c1e903106d59099cbbda97d1f52e9 / . / tests / suites / test_suite_nist_kw.function
blob: eb67c03f0c289266192eb79cbcf33bcc9b0871ad [file] [log] [blame]
Ron Eldor8dd03cd2018-07-15 09:37:28 +0300[diff] [blame^]1/* BEGIN_HEADER */
2#include "mbedtls/nist_kw.h"
3/* END_HEADER */
4
5/* BEGIN_DEPENDENCIES
6 * depends_on:MBEDTLS_NIST_KW_C
7 * END_DEPENDENCIES
8 */
9
10/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */
11void mbedtls_nist_kw_self_test( )
12{
13 TEST_ASSERT( mbedtls_nist_kw_self_test( 1 ) == 0 );
14}
15/* END_CASE */
16
17/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
18void mbedtls_nist_kw_mix_contexts( )
19{
20 mbedtls_nist_kw_context ctx1, ctx2;
21 unsigned char key[16];
22 unsigned char plaintext[32];
23 unsigned char ciphertext1[40];
24 unsigned char ciphertext2[40];
25 size_t output_len, i;
26
27 memset( plaintext, 0, sizeof( plaintext ) );
28 memset( ciphertext1, 0, sizeof( ciphertext1 ) );
29 memset( ciphertext2, 0, sizeof( ciphertext2 ) );
30 memset( key, 0, sizeof( key ) );
31
32 /*
33 * 1. Check wrap and unwrap with two seperate contexts
34 */
35 mbedtls_nist_kw_init( &ctx1 );
36 mbedtls_nist_kw_init( &ctx2 );
37
38 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx1,
39 MBEDTLS_CIPHER_ID_AES,
40 key, sizeof( key ) * 8,
41 1 ) == 0 );
42
43 TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KW,
44 plaintext, sizeof( plaintext ),
45 ciphertext1, &output_len,
46 sizeof( ciphertext1 ) ) == 0 );
47 TEST_ASSERT( output_len == sizeof( ciphertext1 ) );
48
49 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx2,
50 MBEDTLS_CIPHER_ID_AES,
51 key, sizeof( key ) * 8,
52 0 ) == 0 );
53
54 TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KW,
55 ciphertext1, output_len,
56 plaintext, &output_len,
57 sizeof( plaintext ) ) == 0 );
58
59 TEST_ASSERT( output_len == sizeof( plaintext ) );
60 for( i = 0; i < sizeof( plaintext ); i++ )
61 {
62 TEST_ASSERT( plaintext[i] == 0 );
63 }
64 mbedtls_nist_kw_free( &ctx1 );
65 mbedtls_nist_kw_free( &ctx2 );
66
67 /*
68 * 2. Check wrapping with two modes, on same context
69 */
70 mbedtls_nist_kw_init( &ctx1 );
71 mbedtls_nist_kw_init( &ctx2 );
72 output_len = sizeof( ciphertext1 );
73
74 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx1,
75 MBEDTLS_CIPHER_ID_AES,
76 key, sizeof( key ) * 8,
77 1 ) == 0 );
78
79 TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KW,
80 plaintext, sizeof( plaintext ),
81 ciphertext1, &output_len,
82 sizeof( ciphertext1 ) ) == 0 );
83 TEST_ASSERT( output_len == sizeof( ciphertext1 ) );
84
85 TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KWP,
86 plaintext, sizeof( plaintext ),
87 ciphertext2, &output_len,
88 sizeof( ciphertext2 ) ) == 0 );
89
90 TEST_ASSERT( output_len == sizeof( ciphertext2 ) );
91
92 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx2,
93 MBEDTLS_CIPHER_ID_AES,
94 key, sizeof( key ) * 8,
95 0 ) == 0 );
96
97 TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KW,
98 ciphertext1, sizeof( ciphertext1 ),
99 plaintext, &output_len,
100 sizeof( plaintext ) ) == 0 );
101
102 TEST_ASSERT( output_len == sizeof( plaintext ) );
103
104 for( i = 0; i < sizeof( plaintext ); i++ )
105 {
106 TEST_ASSERT( plaintext[i] == 0 );
107 }
108
109 TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KWP,
110 ciphertext2, sizeof( ciphertext2 ),
111 plaintext, &output_len,
112 sizeof( plaintext ) ) == 0 );
113
114 TEST_ASSERT( output_len == sizeof( plaintext ) );
115
116 for( i = 0; i < sizeof( plaintext ); i++ )
117 {
118 TEST_ASSERT( plaintext[i] == 0 );
119 }
120
121exit:
122 mbedtls_nist_kw_free( &ctx1 );
123 mbedtls_nist_kw_free( &ctx2 );
124}
125/* END_CASE */
126
127/* BEGIN_CASE */
128void mbedtls_nist_kw_setkey( int cipher_id, int key_size,
129 int is_wrap, int result )
130{
131 mbedtls_nist_kw_context ctx;
132 unsigned char key[32];
133 int ret;
134
135 mbedtls_nist_kw_init( &ctx );
136
137 memset( key, 0x2A, sizeof( key ) );
138 TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
139
140 ret = mbedtls_nist_kw_setkey( &ctx, cipher_id, key, key_size, is_wrap );
141 TEST_ASSERT( ret == result );
142
143exit:
144 mbedtls_nist_kw_free( &ctx );
145}
146/* END_CASE */
147
148/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
149void nist_kw_plaintext_lengths( int in_len, int out_len, int mode, int res )
150{
151 mbedtls_nist_kw_context ctx;
152 unsigned char key[16];
153 unsigned char *plaintext = NULL;
154 unsigned char *ciphertext = NULL;
155 size_t output_len = out_len;
156
157 mbedtls_nist_kw_init( &ctx );
158
159 memset( key, 0, sizeof( key ) );
160
161 if (in_len == 0)
162 {
163 /* mbedtls_calloc can return NULL for zero-length buffers. Make sure we
164 * always have a plaintext buffer, even if the length is 0. */
165 plaintext = mbedtls_calloc( 1, 1 );
166 }
167 else
168 {
169 plaintext = mbedtls_calloc( 1, in_len );
170 }
171 TEST_ASSERT( plaintext != NULL );
172 ciphertext = mbedtls_calloc( 1, output_len );
173 TEST_ASSERT( ciphertext != NULL );
174
175 memset( plaintext, 0, in_len );
176 memset( ciphertext, 0, output_len );
177
178
179 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
180 key, 8 * sizeof( key ), 1 ) == 0 );
181
182 TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx, mode, plaintext, in_len,
183 ciphertext, &output_len,
184 output_len ) == res );
185 if( res == 0 )
186 {
187 if( mode == MBEDTLS_KW_MODE_KWP )
188 TEST_ASSERT( output_len == (size_t) in_len + 8 -
189 ( in_len % 8 ) + 8 );
190 else
191 TEST_ASSERT( output_len == (size_t) in_len + 8 );
192 }
193 else
194 {
195 TEST_ASSERT( output_len == 0 );
196 }
197
198exit:
199 mbedtls_free( ciphertext );
200 mbedtls_free( plaintext );
201 mbedtls_nist_kw_free( &ctx );
202}
203/* END_CASE */
204
205/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
206void nist_kw_ciphertext_lengths( int in_len, int out_len, int mode, int res )
207{
208 mbedtls_nist_kw_context ctx;
209 unsigned char key[16];
210 unsigned char *plaintext = NULL;
211 unsigned char *ciphertext = NULL;
212 int unwrap_ret;
213 size_t output_len = out_len;
214
215 mbedtls_nist_kw_init( &ctx );
216
217 memset( key, 0, sizeof( key ) );
218
219 plaintext = mbedtls_calloc( 1, output_len );
220 TEST_ASSERT( plaintext != NULL );
221 ciphertext = mbedtls_calloc( 1, in_len );
222 TEST_ASSERT( ciphertext != NULL );
223
224 memset( plaintext, 0, output_len );
225 memset( ciphertext, 0, in_len );
226
227
228 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
229 key, 8 * sizeof( key ), 0 ) == 0 );
230 unwrap_ret = mbedtls_nist_kw_unwrap( &ctx, mode, ciphertext, in_len,
231 plaintext, &output_len,
232 output_len );
233
234 if( res == 0 )
235 TEST_ASSERT( unwrap_ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
236 else
237 TEST_ASSERT( unwrap_ret == res );
238
239 TEST_ASSERT( output_len == 0 );
240
241exit:
242 mbedtls_free( ciphertext );
243 mbedtls_free( plaintext );
244 mbedtls_nist_kw_free( &ctx );
245}
246/* END_CASE */
247
248/* BEGIN_CASE */
249void mbedtls_nist_kw_wrap( int cipher_id, int mode,
250 char *key_hex, char *msg_hex,
251 char *result_hex )
252{
253 unsigned char key[32];
254 unsigned char msg[512];
255 unsigned char result[528];
256 unsigned char expected_result[528];
257 mbedtls_nist_kw_context ctx;
258 size_t key_len, msg_len, output_len, result_len, i, padlen;
259
260 mbedtls_nist_kw_init( &ctx );
261
262 memset( key, 0x00, sizeof( key ) );
263 memset( msg, 0x00, sizeof( msg ) );
264 memset( result, '+', sizeof( result ) );
265
266 key_len = unhexify( key, key_hex );
267 msg_len = unhexify( msg, msg_hex );
268 result_len = unhexify( expected_result, result_hex );
269 output_len = sizeof( result );
270
271 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, cipher_id, key, key_len * 8, 1 )
272 == 0 );
273
274 /* Test with input == output */
275 TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx, mode, msg, msg_len,
276 result, &output_len, sizeof( result ) ) == 0 );
277
278 TEST_ASSERT( output_len == result_len );
279
280 TEST_ASSERT( memcmp( expected_result, result, result_len ) == 0 );
281
282 padlen = ( msg_len % 8 != 0 ) ? 8 - (msg_len % 8 ) : 0;
283 /* Check that the function didn't write beyond the end of the buffer. */
284 for( i = msg_len + 8 + padlen; i < sizeof( result ); i++ )
285 {
286 TEST_ASSERT( result[i] == '+' );
287 }
288
289exit:
290 mbedtls_nist_kw_free( &ctx );
291}
292/* END_CASE */
293
294/* BEGIN_CASE */
295void mbedtls_nist_kw_unwrap( int cipher_id, int mode,
296 char *key_hex, char *msg_hex,
297 char *result_hex, int expected_ret )
298{
299 unsigned char key[32];
300 unsigned char msg[528];
301 unsigned char result[528];
302 unsigned char expected_result[528];
303 mbedtls_nist_kw_context ctx;
304 size_t key_len, msg_len, output_len, result_len, i;
305
306 mbedtls_nist_kw_init( &ctx );
307
308 memset( key, 0x00, sizeof( key ) );
309 memset( msg, 0x00, sizeof( msg ) );
310 memset( result, '+', sizeof( result ) );
311 memset( expected_result, 0x00, sizeof( expected_result ) );
312
313 key_len = unhexify( key, key_hex );
314 msg_len = unhexify( msg, msg_hex );
315 result_len = unhexify( expected_result, result_hex );
316 output_len = sizeof( result );
317
318 TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, cipher_id, key, key_len * 8, 0 )
319 == 0 );
320
321 /* Test with input == output */
322 TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx, mode, msg, msg_len,
323 result, &output_len, sizeof( result ) ) == expected_ret );
324 if( expected_ret == 0 )
325 {
326 TEST_ASSERT( output_len == result_len );
327 TEST_ASSERT( memcmp( expected_result, result, result_len ) == 0 );
328 }
329 else
330 {
331 TEST_ASSERT( output_len == 0 );
332 }
333
334 /* Check that the function didn't write beyond the end of the buffer. */
335 for( i = msg_len - 8; i < sizeof( result ); i++ )
336 {
337 TEST_ASSERT( result[i] == '+' );
338 }
339
340exit:
341 mbedtls_nist_kw_free( &ctx );
342}
343/* END_CASE */